drf学习笔记

今日内容概要

• drf之请求与响应
• drf之视图组件
• 两个视图基类

今日内容详细

补充知识

反射：通过字符串动态的获取，设置，判断 对象中得属性或方法
    -getattr： res=getattr(self, 'run', None)
    -setattr:  setattr(self, 'speak', 内存地址)    self.speak()
    -hasattr:  hasattr(self, 'run')

drf之请求与响应

Request和Response类

Request类

REST framework 传入视图的request对象不再是Django默认的HttpRequest对象，而是REST framework提供的扩展了HttpRequest类的Request类的对象。

REST framework 提供了Parser解析器，在接收到请求后会自动根据Content-Type指明的请求数据类型（如JSON、表单等）将请求数据进行parse解析，解析为类字典[QueryDict]对象保存到Request对象中。

Request对象的数据是自动根据前端发送数据的格式进行解析之后的结果。所以无论前端发送哪种格式的数据，我们都可以以统一的方式读取数据。

# 继承APIView后，请求对象：每一次请求都是一个新的request
属性或方法：

1.data
    request.data 返回解析之后的请求体数据。
      1） 包含了解析之后的文件和非文件数据
      2）包含了对POST、PUT、PATCH请求方式解析后的数据
      3）利用了REST framework的parsers解析器，不仅支持表单类型数据，也支持JSON数据

原生django，put提交的数据在request.POST中是取不到的，要取的话得在request.body中拿

2.query_params
    request.query_params与Django标准的request.GET相同，只是更换了更正确的名称而已。

Response类

Response(data, status=None, headers=None, template_name=None, content_type=None)

# 重要参数使用方法
data=None,   # 字典，列表---》序列化成json格式字符串，返回给前端（放在http响应的body中了）
status=None,  # http 响应的状态码，默认是200，201   
      -为了方便设置http响应状态码，REST framewrok在rest_framework.status模块中提供了常用状态码常量，可以直接导进来用。
headers=None,      # http的响应头，字典 {name:lqz}

# 不常用
template_name=None, # 了解：在浏览器中看到好看的页面，指定的模板
content_type=None  # 响应的编码格式(json)

代码演示：
d = {'name': 'lqz', 'age': 19}
return Response(d, status=status.HTTP_201_CREATED, headers={'name': 'lqz'})


# 补充：原生django在响应头中加数据
d = {'name': 'lqz', 'age': 19}
# 原生djagno向响应头中放数据如何做？四件套都可以用
res = HttpResponse(json.dumps(d))
res=JsonResponse(d)
res['rrr'] = 'yyyy'
return res


属性或方法：
1）.data
传给response对象的序列化后，但尚未render处理的数据
2）.status_code
状态码的数字
3）.content
经过render处理后的响应数据

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

请求编码

# 默认能解析：
    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格式

# 自定义我们的接口接受什么数据格式
方式一：全局配置
在项目配置文件settings.py中修改配置，以后所有的接口都遵循这个配置
    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

响应编码

# 如果用浏览器，就能看到好看的样子，如果用postman看到json格式
    -默认请情况下，响应的编码是根据客户端类型决定的

# 全局配置：在项目的配置文件
    REST_FRAMEWORK = {
        'DEFAULT_RENDERER_CLASSES': [
            'rest_framework.renderers.JSONRenderer', # json格式
            'rest_framework.renderers.BrowsableAPIRenderer', #浏览器的格式
          ]
      }

# 局部配置：
class TestView(APIView):
    renderer_classes = [JSONRenderer, BrowsableAPIRenderer]
    
实际编码中，响应一般不配置，就用默认的。

drf之视图组件

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

两个视图基类

1.APIView

rest_framework.views.APIView

APIView是REST framework提供的所有视图的基类，继承自Django的View父类。

APIView与View的不同之处在于：
1）传入到视图方法中的是REST framework的Request对象，而不是Django的HttpRequeset对象；
2）视图方法可以返回REST framework的Response对象，视图会为响应数据设置（render）符合前端要求的格式；
3）任何APIException异常都会被捕获到，并且处理成合适的响应信息；
4）在进行dispatch()分发前，会对请求进行身份认证、权限检查、流量控制。

2.GenericAPIView

GenericAPIView继承了APIView

类属性：
    1）queryset 指明使用的数据查询集
    queryset = User.objects.all()
    2）serializer_class 指明视图使用的序列化器
    serializer_class = UserSerializer

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

基于APIView写5个接口

from rest_framework.views import APIView
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('')

基于GenericAPIView写5个接口

from rest_framework.generics import GenericAPIView
class UserView(GenericAPIView):
    queryset = User.objects.all()
    serializer_class = UserSerializer

    def get(self, request):
        book_list = self.get_queryset()
        ser = self.get_serializer(instance=book_list, 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 UserDetailView(GenericAPIView):
    queryset = User.objects.all()
    serializer_class = UserSerializer
    def get(self, request, pk):
        book = self.get_object()
        ser = self.get_serializer(instance=book)
        return Response(ser.data)

    def put(self, request, pk):
        book = self.get_object()
        ser = self.get_serializer(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):
        self.get_queryset().filter(pk=pk).delete()
        return Response('')

作业

# urls.py

urlpatterns = [
    path('admin/', admin.site.urls),
    path('books/', views.Bookview.as_view({'get': 'list', 'post': 'create'})),
    re_path('books/(?P<pk>\d+)', views.Bookview.as_view({"get": "retrieve", "put": "update", "delete": "destroy"}))
]


# view.py

from django.shortcuts import render
# Create your views here.
from rest_framework.generics import GenericAPIView
from .models import Book
from .serializer import Bookserializer
from rest_framework.response import Response
from rest_framework.status import HTTP_201_CREATED
from rest_framework.viewsets import GenericViewSet


# class Bookview(GenericAPIView):
#     queryset = Book.objects.all()
#     serializer_class = Bookserializer
#
#     def get(self, request):
#         book_list = self.get_queryset()
#         res = self.get_serializer(instance=book_list, many=True)
#         return Response(res.data)
#
#     def post(self, request):
#         res = self.get_serializer(data=request.data)
#         if res.is_valid():
#             res.save()
#             return Response({'code': 100, 'msg': '新增成功'}, status=HTTP_201_CREATED)
#         else:
#             return Response({'code': 101, 'msg': res.errors})
#
#
# class Bookdetailview(GenericAPIView):
#     queryset = Book.objects.all()
#     serializer_class = Bookserializer
#
#     def get(self, request, pk):
#         book = self.get_object()
#         res = self.get_serializer(instance=book)
#         return Response(res.data)
#
#     def put(self, request, pk):
#         book = self.get_object()
#         res = self.get_serializer(instance=book, data=request.data)
#         if res.is_valid():
#             res.save()
#             return Response({'code': 100, 'msg': '修改成功'})
#         else:
#             return Response({'code': 101, 'msg': res.errors})
#
#     def delete(self, request, pk):
#         self.get_queryset().filter(pk=pk).delete()
#         return Response('')


# 五个父类
class Getall():
    def get(self, request):
        book_list = self.get_queryset()
        res = self.get_serializer(instance=book_list, many=True)
        return Response(res.data)


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


class Getone():
    def get(self, request, pk):
        book = self.get_object()
        res = self.get_serializer(instance=book)
        return Response(res.data)


class Update():
    def put(self, request, pk):
        book = self.get_object()
        res = self.get_serializer(instance=book, data=request.data)
        if res.is_valid():
            res.save()
            return Response({'code': 100, 'msg': '修改成功'})
        else:
            return Response({'code': 101, 'msg': res.errors})


class Del():
    def delete(self, request, pk):
        self.get_queryset().filter(pk=pk).delete()
        return Response('')


# 九个子类
class Listall(GenericAPIView, Getall):
    pass


class Createall(GenericAPIView, Create):
    pass


class Single(GenericAPIView, Getone):
    pass


class Updateone(GenericAPIView, Update):
    pass


class delone(GenericAPIView, Del):
    pass


class Getall2Create(GenericAPIView, Getall, Create):
    pass


class Getone2Update(GenericAPIView, Getone, Update):
    pass


class Getone2Del(GenericAPIView, Getone, Del):
    pass


class Getone2Update2Del(GenericAPIView, Getone, Update, Del):
    pass


from rest_framework.viewsets import ModelViewSet


class Bookview(ModelViewSet):
    queryset = Book.objects.all()
    serializer_class = Bookserializer