drf_day04

1.dir入门

-前后端开发模式
-API接口
-postman使用
-序列化和反序列化
-restful规范
-drf：第三方app–》快速实现符合restful规范的接口
-以后写的都是视图类，都是继承APIView及其子类
-cbv的执行流程
-路由中：视图类.as_view()---->View的as_view类的绑定方法----》闭包函数view
-请求来了：执行闭包函数view(request)—>self.dispatch(request, *args, **kwargs)
-View:dispatch:根据请求的方式，执行视图函数中以请求方式命名的方法
-反射：通过字符串动态的获取，设置，判断 对象中得属性或方法
-getattr： res=getattr(self,‘run’,None)
-setattr: setattr(self,‘speak’,内存地址) self.speak()
-hasattr: hasattr(self,‘run’)
-APIView 继承了View，执行流程
-APIView的as_view了：1 调用了父类的as_view 2 去掉了csrf
-请求来了，执行View的as_view的闭包view—》dispatch
-APIView的dispatch
-1 包装了新的request
-2 在执行视图函数之前：执行了三大认证
-3 执行了视图函数：请求方式是什么，就执行视图函数中得什么方法
-4 全局异常捕获：全局异常，统一返回格式

-序列化类
-Serializer
-ModelSerializer
-序列化
-反序列化
-校验

-请求与响应
-Request类:属性和方法
-Response类
-视图层（2基类，5个扩展类，9个子类，视图集）
-路由的使用

-认证，频率，权限
-过滤，排序，分页
-全局异常处理
-接口文档：自定生成，自己写
-前后端分离：jwt认证方式–登录
-公司内部：RBAC
-djagno：admin 美化

2 drf之请求与响应

instance ：校验对象数据，是多个的话，many=True

pk 增 删 改，操作数据，使用

urls中使用pk指定路由

2.1 Request

常用属性：
data

request.data 返回解析之后的请求体数据。类似于Django中标准的request.POST和 request.FILES属性，但提供如下特性：

解析文件和非文件数据
对POST .PUT .PATCH 请求方式解析后的数据
利用REST framwork的parsers解析器 支持表单类型数据，也支持JSON数据

query_params

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

2.2 Response

rest_framework.response.Response

REST framework提供了一个响应类Response，使用该类构造响应对象时，响应的具体数据内容会被转换（render渲染）成符合前端需求的类型。

REST framework提供了Renderer 渲染器，用来根据请求头中的Accept（接收数据类型声明）来自动转换响应数据到对应格式。如果前端请求中未进行Accept声明，则会采用默认方式处理响应数据，我们可以通过配置来修改默认响应格式。

1.data=None, # 字典，列表—》序列化成json格式字符串，返回给前端（放在http响应的body中了） 2.status=None, # http 响应的状态码，默认是200，201
drf帮咱们把所有的http响应状态码都做成了常量，可以直接导进来用

headers=None, # http的响应头，字典 {name:lqz}

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

)

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

能够解析的请求编码
默认解析的:

-urlencoded

-json

-form_data

实通过配置完成：项目中没有配置，是在drf内置的配置文件中提前配好了

REST_FRAMEWORK = {
    'DEFAULT_RENDERER_CLASSES': (  # 默认响应渲染类，
        'rest_framework.renderers.JSONRenderer',  # json渲染器， 可以解析json格式
        'rest_framework.renderers.BrowsableAPIRenderer',  # 浏览API渲染器 可以解析form_data
        'rest_framework.parsers.FormParser', 可以解析urlencoded格式
    )
}

方式一：全局配置—》项目配置文件—》以后所有的接口都遵循这个配置

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

2.4 响应编码

如果用浏览器，好看的样子，如果用postman看到json格式
默认请情况下，响应的编码是根据客户端类型决定的
全局配置：在项目的配置文件

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

局部配置：

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

实际编码中，响应一般步配，就用默认

3.rf之视图组件

由于drf提供了一个顶层的视图类APIView，咱们可以通过继承APIView写视图类

后期咱们要写的代码可能重复代码比较多，就可以使用面向对象的继承，封装

3.1 2个视图基类

model.py

from django.db import models


# Create your models here.


class Book(models.Model):
    name = models.CharField(max_length=32)
    price = models.CharField(max_length=32)
    publish = models.CharField(max_length=32)


class User(models.Model):
    name = models.CharField(max_length=32)
    password = models.CharField(max_length=32)
    gender = models.CharField(max_length=32)

serializer.py

from rest_framework import serializers
from .models import Book,User


class BookSerializer(serializers.ModelSerializer):
    class Meta:
        model = Book
        fields = '__all__'

class UserSerializer(serializers.ModelSerializer):
    class Meta:
        model = User
        fields = '__all__'

ulrs.py

from django.contrib import admin
from django.urls import path
from app01 import views

urlpatterns = [
    path('admin/', admin.site.urls),
    path('test/', views.TestView.as_view()),
    path('books/', views.BookView.as_view()),
    path('books/<int:pk>', views.BookDetailView.as_view()),
    path('user/', views.UserView.as_view()),
    path('user/<int:pk>', views.UserDetailView.as_view()),
]

APIView

GenericAPIView–>继承了APIView
-类属性：
queryset = User.objects.all()
serializer_class = UserSerializer
-方法：
self.get_object() # 根据pk获取单个数据
self.get_serializer # 获取要使用的序列化类
self.get_queryset() # 获取所有要序列化数据

3.2基于APIView写5个接口

view.py

from django.shortcuts import render
from rest_framework.views import APIView
from rest_framework.response import Response
from app01.models import Book,User
from app01.serializer import BookSerializer,UserSerializer
# Create your views here.


class BookView(APIView):
    def get(self,request):
        book_list = Book.objects.all()
        ser = BookSerializer(instance=book_list,many=True)
        return Response(ser.data)


    def post(self,request):
        ser =BookSerializer(data=request)
        if ser.is_valid():
            ser.save()
            return  Response({'code':100,'msg':'添加成功'})
        else:
            return Response({'code':101,'msg':'添加失败'})

class BookDetaView(APIView):
    def get(self,request,pk):
        book = Book.objects.filter(pk = pk).first()
        ser = BookSerializer(instance=book)
        return Response(ser.data)



    def put(self,request,pk):
        book = Book.objects.filter(pk=pk).first()
        ser = BookSerializer(instance=book,data=request.data)
        if ser.is_valid():
            ser.save()
            return Response({'code':100,'msg':'修改成功'})
        else:
            return Response({'code':101,'msg':'修改失败'})

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

3.3.基于GenericAPIView写5个接口

wiew.py

from django.shortcuts import render
from rest_framework.views import APIView
from rest_framework.response import Response
from app01.models import Book,User
from app01.serializer import BookSerializer,UserSerializer
# Create your views here.



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':'添加成功'})
         else:
             return Response({'code':101,'msg':'添加失败'})


class UserDataView(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':'修改成功'})
        else:
            return Response({'code':100,'msg':'修改失败'})


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

使用面向对象，写5个父类， 继承GenericAPIView+某几个父类后，就有某几个接口 新增1条 GenericAPIView+Create

from django.shortcuts import render
from rest_framework.views import APIView
from rest_framework.response import Response
from app01.models import Book, User
from app01.serializer import BookSerializer, UserSerializer
# Create your views here.


from rest_framework.generics import GenericAPIView

from rest_framework.generics import GenericAPIView


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


class b():
    def post(self, request):
        ser = self.get_serializer(data=request.data)
        if ser.is_valid():
            ser.save()
            return Response({'code': 100, 'msg': '添加成功'})
        else:
            return Response({'code': 101, 'msg': '添加失败'})


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


class d():
    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': '修改成功'})
        else:
            return Response({'code': 100, 'msg': '修改失败'})


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


class UserView(GenericAPIView, a, b):
    queryset = User.objects.all()
    serializer_class = UserSerializer


class UserDataView(GenericAPIView, c, d, e):
    queryset = User.objects.all()
    serializer_class = UserSerializer