$Django importlib与dir知识,手写配置文件, 配置查找顺序 drf分页器&drf版本控制

1  importlib与dir知识

# importlib简介动态导入字符串模块
# 常规导入
from ss.aa import b
from ss import a
print(b,type(b))
#<module 'ss.aa.b' from 'F:\\python37\\pythonfiles\\ss\\aa\\b.py'> #<class 'module'>

# importlib动态导入py文件模块
import importlib
mod=importlib.import_module('ss.aa.b')
print(mod,type(mod))
#<module 'ss.aa.b' from 'F:\\python37\\pythonfiles\\ss\\aa\\b.py'> #<class 'module'>
print(dir(a))

2  手写配置文件

#默认配置setting包下的init.py内部
import os
from setting import settings   #settings.py 内部 AAA=NONE
class setting:
    def __init__(self):
        user_setting=os.environ.get('user_setting')
        for key in dir(settings):
            if key.isupper():
                setattr(self,key,getattr(settings,key))
        import importlib
        mod=importlib.import_module(user_setting)
        for key in dir(mod):
            if key.isupper():
                setattr(self,key,getattr(mod,key))
setting_obj=setting()

#用户user_setting包下的setting.py 内部 AAA="aaa"

#run.py执行文件
import os
os.environ.setdefault('user_setting','user_setting.user_setting')
from setting import setting_obj
print(setting_obj.AAA)

3 配置查找顺序

　1先找类里的 2再找setting里用户配置的 3最后找默认django.conf.setting内默认的

4  drf分页器

from paginnator import models
from rest_framework.viewsets import ViewSetMixin
from rest_framework.views import APIView
from paginnator import myserverlize
from rest_framework.pagination import PageNumberPagination,LimitOffsetPagination,CursorPagination
from rest_framework.response import Response
# 普通分页器  #当前页的数据 序列化 返回
class Book(ViewSetMixin,APIView): #半自动路由控制
    def list(self,request,*args,**kwargs):
        books=models.Book.objects.all()
        p=PageNumberPagination()
        #每页显示不超过
        p.max_page_size=10
        #每页默认显示几条
        p.page_size=2
        #第几页
        p.page_query_param='aaa'
        #第几页显示几条(修改默认显示)
        p.page_size_query_param = 'bbb'
        # 当前页对象
        p_now=p.paginate_queryset(books,request,view=self)
        # 序列化
        p_now_now=myserverlize.Myserializers(p_now,many=True)
        # 返回分页器自带的Response(上下页链接，总条数,当前页数据)
        # return p.get_paginated_response(data=p_now_now.data)
        #返回当前页数据
        return Response(p_now_now.data)
    def list_one(self,request,*args,**kwargs):
        #查看某条数据，1条数据
        pass

# 偏移分页器
class Book(ViewSetMixin,APIView): #半自动路由控制
    def list(self,request,*args,**kwargs):
        books=models.Book.objects.all()
        p=LimitOffsetPagination()
        # 默认显示几条
        p.default_limit=3
        # 最大显示条数
        p.max_limit =10
        # p.limit_query_param = 'limit'
        # 偏移(?limit=13&offset=3) 从4算起显示10条
        # p.offset_query_param = 'offset'
        # 当前页数据
        p_now=p.paginate_queryset(books,request,view=self)
        p_now_now=myserverlize.Myserializers(p_now,many=True)
        return Response(p_now_now.data)
    def list_one(self,request,*args,**kwargs):
        #查看某条数据，1条数据
        pass
#加密分页器
#http://127.0.0.1:8000/book/?cursor=cD0xMg%3D%3D
class Book(ViewSetMixin,APIView): #半自动路由控制
    def list(self,request,*args,**kwargs):
        books=models.Book.objects.all()
        p=CursorPagination()
        p.ordering='id'
        p.page_size=4
        p.cursor_query_param = 'cursor'
        p_now=p.paginate_queryset(books,request,view=self)
        p_now_now=myserverlize.Myserializers(p_now,many=True)
        return p.get_paginated_response(p_now_now.data)
    def list_one(self,request,*args,**kwargs):
        #查看某条数据，1条数据
        pass

3种分页器

#第一种 ?page=4&page_size=100 每页显示100条
class PageNumberPagination(BasePagination):
    """
    A simple page number based style that supports page numbers as
    query parameters. For example:

    http://api.example.org/accounts/?page=4
    http://api.example.org/accounts/?page=4&page_size=100
    """
    page_size = api_settings.PAGE_SIZE #?page=4 每页显示4条
    page_query_param = 'page'
    page_size_query_param = None  # ?page=4&page_size=100 每页显示100条
    max_page_size = None

#第二种   ？offset=3&limit=13 从4算起显示13条
class LimitOffsetPagination(BasePagination):
    """
    A limit/offset based style. For example:

    http://api.example.org/accounts/?limit=100
    http://api.example.org/accounts/?offset=400&limit=100
    """
    default_limit = api_settings.PAGE_SIZE
    limit_query_param = 'limit'
    offset_query_param = 'offset'
    max_limit = None

#第三种 ?cursor=cD0xMg%3D%3D
class CursorPagination(BasePagination):
    """
    The cursor pagination implementation is necessarily complex.
    For an overview of the position/offset style we use, see this post:
    https://cra.mr/2011/03/08/building-cursors-for-the-disqus-api
    """
    cursor_query_param = 'cursor'
    page_size = api_settings.PAGE_SIZE
    ordering = '-created'
    page_size_query_param = None
    max_page_size = None

#自带的获取当前页数据
def paginate_queryset(self, queryset, request, view=None):
        pass
#自带的返回 一个带上下链接 总统条数 当前数据
    def get_paginated_response(self, data):
        return Response(OrderedDict([
            ('next', self.get_next_link()),
            ('previous', self.get_previous_link()),
            ('results', data)
        ]))

5 drf版本控制

class BaseVersioning(object):
    default_version = api_settings.DEFAULT_VERSION
    allowed_versions = api_settings.ALLOWED_VERSIONS
    version_param = api_settings.VERSION_PARAM

#
DEFAULTS={
# Versioning
    'DEFAULT_VERSION': None,
    'ALLOWED_VERSIONS': None,
    'VERSION_PARAM': 'version',
}

BaseVersioning部分源码

class URLPathVersioning(BaseVersioning):
    """
    To the client this is the same style as `NamespaceVersioning`.
    The difference is in the backend - this implementation uses
    Django's URL keyword arguments to determine the version.

    An example URL conf for two views that accept two different versions.

    urlpatterns = [
        url(r'^(?P<version>[v1|v2]+)/users/$', users_list, name='users-list'),
        url(r'^(?P<version>[v1|v2]+)/users/(?P<pk>[0-9]+)/$', users_detail, name='users-detail')
    ]

    GET /1.0/something/ HTTP/1.1
    Host: example.com
    Accept: application/json
    """
    def determine_version(self, request, *args, **kwargs):
        version = kwargs.get(self.version_param, self.default_version)
        if not self.is_allowed_version(version):
            raise exceptions.NotFound(self.invalid_version_message)
        return version

URLPathVersioning部分源码

class QueryParameterVersioning(BaseVersioning):
    """
    GET /something/?version=0.1 HTTP/1.1
    Host: example.com
    Accept: application/json
    """
    def determine_version(self, request, *args, **kwargs):
        version = request.query_params.get(self.version_param, self.default_version)
        if not self.is_allowed_version(version):
            raise exceptions.NotFound(self.invalid_version_message)
        return version

QueryParameterVersioning部分源码

    def initial(self, request, *args, **kwargs):
        """
        Runs anything that needs to occur prior to calling the method handler.
        """
        # Determine the API version, if versioning is in use.
        version, scheme = self.determine_version(request, *args, **kwargs)
        request.version, request.versioning_scheme = version, scheme

dispacth

分析:1view对象 2从dispacth进入到版本类 3版本类在进入到基板类取到默认设置返回 得到

request.version, request.versioning_scheme = version, scheme #版本v1（默认version） ,版本类名(默认NONE)

使用

#URLPathVersioning（url）
url(r'(?P<version>[v1|v2|v3]+)/book/',views.Book.as_view({'get':'list'}) ),

#URLPathVersioning（view）

class Book(ViewSetMixin,APIView): #半自动路由控制
    versioning_class=URLPathVersioning
    def list(self,request,*args,**kwargs):
        books=models.Book.objects.all()
        p=CursorPagination()
        p.ordering='id'
        p.page_size=4
        p.cursor_query_param = 'cursor'
        p_now=p.paginate_queryset(books,request,view=self)
        p_now_now=myserverlize.Myserializers(p_now,many=True)
        return p.get_paginated_response(p_now_now.data)

#setting配置
REST_FRAMEWORK = {
    # 每页显示两条
    'PAGE_SIZE':10,
    # 'DEFAULT_VERSIONING_CLASS':'', #全局设置
    'VERSION_PARAM':'version',
    'DEFAULT_VERSION':'v1',
    'ALLOWED_VERSIONS': ['v1', 'v2'],
}