drf-分页器 响应器 url控制器 解析器

一、分页器

1、简单分页（查看第n页，每页显示m条）：

使用方法：

　　a、导入PageNumberPagination类；

　　b、实例化产生一个对象；

　　c、需要配置四个参数：page_size(必须指定，可以直接赋值或者在setting中指定),page_query_param,page_size_qury_param,max_page_size；

　　d、调用paginate_queryset(list,request,self)方法，获取页面中显示的数据；

　　e、序列化上个步骤中返回的数据。

 属性介绍：

　　a、page_size：控制每页的显示条数；

　　b、page_query_param：控制查询第几页的查询参数；

　　c、page_size_qury_param：控制每页的最大显示条数；

　　d、max_page_size：控制每页最大的显示条数，先满足他后，才去满足page_size_qury_param。

---- 示例：

简单分页器视图代码：

from rest_framework.pagination import PageNumberPagination
# 一 基本使用：url=url=http://127.0.0.1:8000/pager/?page=2&size=3，size无效
class  Pager(APIView):
    def get(self,request,*args,**kwargs):
        # 获取所有数据
        ret=models.Book.objects.all()
        # 创建分页对象
        page=PageNumberPagination()
        # 在数据库中获取分页的数据
        page_list=page.paginate_queryset(ret,request,view=self)
        # 对分页进行序列化
        ser=BookSerializer1(instance=page_list,many=True)
        return Response(ser.data)
# 二 自定制 url=http://127.0.0.1:8000/pager/?page=2&size=3
# size=30，无效，最多5条
class Mypage(PageNumberPagination):
    page_size = 2
    page_query_param = 'page'
    # 定制传参
    page_size_query_param = 'size'
    # 最大一页的数据
    max_page_size = 5
class  Pager(APIView):
    def get(self,request,*args,**kwargs):
        # 获取所有数据
        ret=models.Book.objects.all()
        # 创建分页对象
        page=Mypage()
        # 在数据库中获取分页的数据
        page_list=page.paginate_queryset(ret,request,view=self)
        # 对分页进行序列化
        ser=BookSerializer1(instance=page_list,many=True)
        # return Response(ser.data)
        # 这个也是返回Response对象，但是比基本的多了上一页，下一页，和总数据条数（了解即可）
        return page.get_paginated_response(ser.data)

settings

REST_FRAMEWORK = {
    # 每页显示两条
    'PAGE_SIZE':2
}

路由：

url(r'^pager/$', views.Pager.as_view()),

序列化：

class BookSerializer1(serializers.ModelSerializer):
    class Meta:
        model=models.Book
        # fields="__all__"
        exclude=('authors',)

2、偏移分页（在第n个位置，向后查看m条数据）

使用方法同简单分页

需要设置的属性：

　　a、default limit：默认每页显示的条数，默认偏移的数量；

　　b、limit_query_param:往后偏移多少条；

　　c、offset_query_param:标杆值  用默认值offset；

　　limit_query_param+offset_query_param联合起来用: 例子：访问:http://127.0.0.1:8000/books/?limit=1&offset=5  表示:以数据的第5条作为标杆,往后偏移1条

　　d、max_limit:最大偏移的条数(最大取出的条数)。

# http://127.0.0.1:8000/pager/?offset=4&limit=3
from rest_framework.pagination import LimitOffsetPagination
# 也可以自定制，同简单分页
class  Pager(APIView):
    def get(self,request,*args,**kwargs):
        # 获取所有数据
        ret=models.Book.objects.all()
        # 创建分页对象
        page=LimitOffsetPagination()
        # 在数据库中获取分页的数据
        page_list=page.paginate_queryset(ret,request,view=self)
        # 对分页进行序列化
        ser=BookSerializer1(instance=page_list,many=True)
        # return page.get_paginated_response(ser.data)
        return Response(ser.data)

3、CursorPagination(加密分页，只能查看上一页和下一页，速度快）

属性介绍：

　　a、page_size:每页显示的条数

　　b、cursor_query_param:不需要变动

　　c、ordering：排序方式

　　通过get_paginated_response返回结果中带上一页和下一页的链接地址

from rest_framework.pagination import CursorPagination
# 看源码，是通过sql查询，大于id和小于id
class  Pager(APIView):
    def get(self,request,*args,**kwargs):
        # 获取所有数据
        ret=models.Book.objects.all()
        # 创建分页对象
        page=CursorPagination()
        page.ordering='nid'
        # 在数据库中获取分页的数据
        page_list=page.paginate_queryset(ret,request,view=self)
        # 对分页进行序列化
        ser=BookSerializer1(instance=page_list,many=True)
        # 可以避免页码被猜到
        return page.get_paginated_response(ser.data)

二、响应器

根据用户的url请求或用户可接受的类型，筛选出合适的渲染组件，即给用户返回不同数据类型的数据。

rest_framework的几种内置渲染器：

　　1、显示json格式：JSONRenderer

　　2、默认显示格式：BrowsableAPIRenderer（可以修改它的html文件）

　　3、表格方式：AdminRenderer

　　4、form表单方式：HTMLFormRenderer

局部使用：

from rest_framework.renderers import  HTMLFormRenderer,BrowsableAPIRenderer
class BookDetailView(APIView):
    renderer_classes = [HTMLFormRenderer,BrowsableAPIRenderer ]
    def get(self,request,pk):
        book_obj=models.Book.objects.filter(pk=pk).first()
        bs=BookSerializers(book_obj,many=False)
        return Response(bs.data)
    def put(self,request,pk):
        book_obj = models.Book.objects.filter(pk=pk).first()

        bs=BookSerializers(data=request.data,instance=book_obj)
        if bs.is_valid():
            bs.save() # update
            return Response(bs.data)
        else:
            return Response(bs.errors)
    def delete(self,request,pk):
        models.Book.objects.filter(pk=pk).delete()

        return Response("")

全局使用秩序要在settings中配置好即可

REST_FRAMEWORK = {
    'DEFAULT_RENDERER_CLASSES':['rest_framework.renderers.JSONRenderer']
}

自定义显示模板

from rest_framework.renderers import  TemplateHTMLRenderer
class BookDetailView(APIView):
    renderer_classes = [TemplateHTMLRenderer]
    def get(self,request,pk):
        book_obj=models.Book.objects.filter(pk=pk).first()
        bs=BookSerializers(book_obj,many=False)
        return Response(bs.data,template_name='aa.html')


----aa.html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
{{ title }}
{{ publishDate }}
</body>
</html>

三、url控制器

1、自定义路由：

from django.conf.urls import url
from app01 import views
urlpatterns = [
    url(r'^books/$', views.BookView.as_view()),
    url(r'^books/(?P<pk>\d+)$', views.BookDetailView.as_view()),
]

2、半自定义路由：

from django.conf.urls import url
from app01 import views
urlpatterns = [
    url(r'^publish/$', views.PublishView.as_view({'get':'list','post':'create'})),
    url(r'^publish/(?P<pk>\d+)/$', views.PublishView.as_view({'get':'retrieve','put':'update','delete':'destroy'})),

]

3、自动生成路由：

from django.conf.urls import url,include
from app01 import views
from rest_framework import routers
router=routers.DefaultRouter()
# 两个参数，一个是匹配的路由，一个是视图中写的CBV的类
router.register('publish',views.PublishView)
urlpatterns = [
    # http://127.0.0.1:8000/publish/format=json(渲染器通过这个判断，返回渲染的页面)
    # url(r'^publish/', views.PublishView.as_view({'get':'list','post':'create'})),
    # http://127.0.0.1:8000/publish.json(渲染器通过这个判断，返回渲染的页面)
    # url(r'^publish\.(?P<format>\w+)$', views.PublishView.as_view({'get':'list','post':'create'})),
    
    # 可以用 以下方式访问
    # 1 http://127.0.0.1:8000/publish/
    # 2 http://127.0.0.1:8000/publish.json
    # 3 http://127.0.0.1:8000/publish/3
    # 4 http://127.0.0.1:8000/publish/3.json   
    url(r'',include(router.urls))
]


# 视图类
from rest_framework.viewsets import ModelViewSet
class PublishView(ModelViewSet):
    queryset=models.Publish.objects.all()
    serializer_class=PublishSerializers

四、解析器

解析器的作用：解析器是用来解析前端传递的不同数据格式的数据：urlencode,formdata,json等

默认情况下解析所有格式，内置配置了三种解析器

1、JSONParser:解析json格式的数据；

2、FormParser：解析formdata格式数据；

3、MultiPartParse：解析urlencode格式数据。

解析器的局部使用：直接在视图类中配置parser_classes=[JSONParser]

全局使用：在settings中配置：

'DEFAULT_PARSER_CLASSES': (
                'rest_framework.parsers.JSONParser',
                'rest_framework.parsers.FormParser',
                'rest_framework.parsers.MultiPartParser'
            )