drf 请求与响应编码

Tao.686

已于 2022-10-24 19:38:05 修改

阅读量430

点赞数

分类专栏： django 文章标签： django python 后端 1024程序员节

于 2022-09-29 23:02:42 首次发布

本文链接：https://blog.csdn.net/weixin_71967396/article/details/127115551

版权

django 专栏收录该内容

21 篇文章 0 订阅

订阅专栏

drf 请求与响应编码

文章目录

drf 请求与响应编码

1、drf之请求与响应

1.1、Request和Response类

继承APIView后，请求对象：requets 每一次请求都是一个新的request

request 类，属性或方法
data: POST、PUT、PATCH请求方式解析后的数据
原生djagno，put提交的数据在request.POST中是取不到的
query_params
其他的用起来跟之前一样用（FILES,method,path…）—>d底层原理 getattr

1.2、Response类

属性方法

data=None

字典，列表序列化成json格式字符串，返回给前端（放在http响应的body中了）

status=None
http 响应的状态码，默认是200，201

headers=None
http的响应头，字典 {name:admin}
原生django要在响应头中加数据

#原生django要在响应头中加数据
res=JsonResponse(d)
res['rrr'] = 'yyyy'
return res

template_name=None
在浏览器中看到好看的页面，指定的模板

content_type=None
响应的编码格式(json)

1.2、drf 能够解析的请求编码，响应编码

1.2.1、请求编码

默认能解析的编码
urlencoded
form-data
json

其实是在drf内置的配置文件中提前配好了
drf也是有两套，一套是项目中配置settings.py ，一套是默认配置
drf的配置文件settings.py中有 DEFAULT_PARSER_CLASSES（默认的解析类）

'rest_framework.parsers.JSONParser', 可以解析json格式
'rest_framework.parsers.FormParser', 可以解析urlencoded格式
'rest_framework.parsers.MultiPartParser' 可以解析form-data格式

只接受json格式
方式一：全局配置>>>项目配置>>>文件以后所有接口都遵循这个配置

REST_FRAMEWORK = {
                'DEFAULT_PARSER_CLASSES': [
                    'rest_framework.parsers.JSONParser',
                    # 'rest_framework.parsers.FormParser',
                    # 'rest_framework.parsers.MultiPartParser',
                ],
            }

方式二：去不配置

class TestView(APIView):
    		parser_classes = [JSONParser,FormParser,MultiPartParser]

总结：
解析类的使用顺序：优先用视图类自己的，然后用项目配置文件，最后用内置的

实际项目如何配置
基本上都运行JSONParser,FormParser
如果上传文件只允许MultiPartParser

1.2.2、响应编码

默认情况下，响应的编码是根据客户端类型决定的

全局配置在项目的配置文件

REST_FRAMEWORK = {
        'DEFAULT_RENDERER_CLASSES': [
            # 'rest_framework.renderers.JSONRenderer', # json格式
            'rest_framework.renderers.BrowsableAPIRenderer', #浏览器的格式
        ]
    }

局部配置

class TestView(APIView):
    renderer_classes = [JSONRenderer,]

2、drf视图组件

由于drf提供了一个顶层的视图类APIView，咱们可以通过继承APIView写视图类
后期咱们要写的代码可能重复代码比较多，就可以使用面向对象的继承，封装

3、2个视图基类

APIView与APView

3.1、GenericAPIView

GenericAPIView–>继承了APIView
类属性：

queryset = User.objects.all()
serializer_class = UserSerializer

方法：

self.get_object() # 根据pk获取单个数据
self.get_serializer # 获取要使用的序列化类
self.get_queryset() # 获取所有要序列化数据

3.2、基于APIView写5个接口

class UserView(APIView):
    def get(self, request):
        book_list = User.objects.all()
        ser = UserSerializer(instance=book_list, many=True)
        return Response(ser.data)

    def post(self, request):
        ser = UserSerializer(data=request.data)
        if ser.is_valid():
            ser.save()
            return Response({'code': 100, 'msg': "新增成功"}, status=201)
        else:
            return Response({'code': 101, 'msg': ser.errors})

class UserDetailView(APIView):
    def get(self, request, pk):
        book = User.objects.filter(pk=pk).first()
        ser = UserSerializer(instance=book)
        return Response(ser.data)

    def put(self, request, pk):
        book = User.objects.filter(pk=pk).first()
        ser = UserSerializer(instance=book, data=request.data)
        if ser.is_valid():
            ser.save()
            return Response({'code': 100, 'msg': "修改成功"}, status=201)
        else:
            return Response({'code': 101, 'msg': ser.errors})

    def delete(self, request, pk):
        User.objects.filter(pk=pk).delete()
        return Response('')

3.3 基于GenericAPIView写5个接口

from app01.serializer import *
from rest_framework.generics import GenericAPIView
from rest_framework.response import Response

class Book(GenericAPIView):
    queryset = Book.objects.all()
    serializer_class = BookSer

    def get(self, request, pk):
        book_obj = self.get_object()
        ser = self.get_serializer(instance=book_obj)
        return Response(ser.data)

    def put(self, request, pk):
        book_obj = self.get_object()
        ser = self.get_serializer(instance=book_obj, data=request.data)
        if ser.is_valid():
            ser.save()
            return Response({'code': 100, 'msg': '修改成功'}, status=201)
        else:
            return Response({'code': 102, 'msg': ser.errors})

    def delete(self,request,pk):

        self.get_queryset().filter(pk=pk).delete()
        return Response('')

扩展

1 使用GenericAPIView写出book的5个接口

class Books(GenericAPIView):
    queryset = Book.objects.all()
    serializer_class = BookSer

    def get(self, request):
        book_obj = self.get_queryset()
        ser = self.get_serializer(instance=book_obj, many=True)
        return Response(ser.data)

    def post(self, request):
        ser = self.get_serializer(data=request.data)
        if ser.is_valid():
            ser.save()
            return Response({'code': 100, 'msg': '新增成功'}, status=201)
        else:
            return Response({'code': 101, 'msg': ser.errors})


class Book(GenericAPIView):
    queryset = Book.objects.all()
    serializer_class = BookSer

    def get(self, request, pk):
        book_obj = self.get_object()
        ser = self.get_serializer(instance=book_obj)
        return Response(ser.data)

    def put(self, request, pk):
        book_obj = self.get_object()
        ser = self.get_serializer(instance=book_obj, data=request.data)
        if ser.is_valid():
            ser.save()
            return Response({'code': 100, 'msg': '修改成功'}, status=201)
        else:
            return Response({'code': 102, 'msg': ser.errors})

    def delete(self,request,pk):

        self.get_queryset().filter(pk=pk).delete()
        return Response('')

2 使用面向对象，写5个父类，继承GenericAPIView+某几个父类后，就有某几个接口

# 读所有
class GenericGets():
    def get_gets(self, request):
        table_obj = self.get_queryset()
        ser = self.get_serializer(instance=table_obj, many=True)
        return Response(ser.data)


# 写入
class GenericPost():
    def post(self, request):
        ser = self.get_serializer(data=request.data)
        if ser.is_valid():
            ser.save()
            return Response({'code': 100, 'msg': '新增成功'}, status=201)
        else:
            return Response({'code': 101, 'msg': ser.errors})

# # 修改
class GenericPut():
    def put(self, request, pk):
        table_obj = self.get_object()
        ser = self.get_serializer(instance=table_obj, data=request.data)
        if ser.is_valid():
            ser.save()
            return Response({'code': 100, 'msg': '修改成功'}, status=201)
        else:
            return Response({'code': 102, 'msg': ser.errors})



# 读单条
class GenericGetOne():
    def get_one(self, request,pk):
        table_obj = self.get_object()
        ser = self.get_serializer(instance=table_obj)
        return Response(ser.data)




#删除
class GenericDelete():
    def delete(self, request,pk):
        self.get_queryset().filter(pk=pk).delete()
        return Response('')

#视图类
class Books(GenericAPIView,GenericGets,GenericPost):
    queryset = Book.objects.all()
    serializer_class = BookSer
    def get(self,request):
        return super().get_gets(request)
    def post(self,request):
        return super().post(request)


class Book(GenericAPIView,GenericGetOne,GenericPut,GenericDelete):
    queryset = Book.objects.all()
    serializer_class = BookSer

    def get(self,request,pk):
        return super().get_one(request,pk)

    def put(self,request,pk):
        return super().put(request,pk)

    def delete(self,request,pk):
        return super().delete(request,pk)

3 9个视图子类

class Generic_1(GenericGets,GenericPost):
    pass
class Generic_2(GenericGetOne,GenericPut):
    pass
class Generic_3(GenericGetOne,GenericDelete):
    pass
class Generic_4(GenericPut,GenericDelete,):
    pass
class Generic_5(GenericGetOne,GenericPut,GenericDelete):
    pass
class Generic_6(GenericPost):
    pass
class Generic_7(GenericPut):
    pass
class Generic_8(GenericGetOne):
    pass
class Generic_9(GenericDelete):
    pass
class Generic_10(GenericGets):
    pass

4 两个视图类合二为一（99.99%）

class GenericGet():
    def get(self,request,pk=None):
        if pk:
            table_obj = self.get_object()
            ser = self.get_serializer(instance=table_obj)
            return Response(ser.data)

        table_obj = self.get_queryset()
        ser = self.get_serializer(instance=table_obj, many=True)
        return Response(ser.data)



class Generic_Allo(GenericGet,GenericPost,GenericPut,GenericDelete,GenericAPIView):
    pass



class BookView(Generic_Allo):
    queryset = Book.objects.all()
    serializer_class = BookSer

    def get(self,request,pk=None):
        return super(BookView, self).get(request,pk)

    def post(self, request):
        return super().post(request)

    def put(self, request, pk):
        return super().put(request,pk)

    def delete(self, request,pk):
        return super().delete(request,pk)