drf过滤排序分页异常
一、过滤组件
1. 步骤
1. 安装：pip3 install django-filter
2. 注册: settings.py中注册
INSTALLED_APPS = [
...
'django_filters', # 需要注册应用，
]
3. 全局配置 或者 局部配置
全局配置: 'DEFAULT_FILTER_BACKENDS': ('django_filters.rest_framework.DjangoFilterBackend',)
局部配置:
指定所有字段: filter_fields = '__all__'
指定固定字段: filter_fields = ['name', ...] # 提示: 可以元组, 也可以是列表
2. 内置过滤组件
# 缺点: 外键字段的搜索操作将会抛出异常: Related Field got invalid lookup: icontains
# 1）在视图文件views.py中导入drf的搜索组件
from rest_framework.filters import SearchFilter
# 2）将搜索组件配置给群查接口视图类的filter_backends
filter_backends = [SearchFilter]
# 3）配置视图类关联的Model表参与搜索的字段
search_fields = ['name', 'id']
# 4）前台访问该群查接口，采用拼接参数方式用search关键字将搜索目标提供给后台
http://127.0.0.1:8000/course/free/?search=2 # id或name中包含2的所有结果
3. 第三方过滤组件
# 介绍: 争对django内置搜索组件的拓展, 在django内置的基础之上还拓展了外键字段的过滤功能.
# 前提：安装django-filter插件
pip install django-filter (注意: 不要安装成了django-filters)
"""方式一"""
# 1）在视图文件views.py中导入django-filter的功能组件
from django_filters.rest_framework import DjangoFilterBackend
# 2）将搜索组件配置给群查接口视图类的filter_backends
filter_backends = [DjangoFilterBackend]
# 3）配置视图类关联的Model表可以分类的字段（通常是可以分组的字段）
filter_fields = ['course_category']
# 4）前台访问该群查接口，采用拼接参数方式用分类course_category字段将分类条件提供给后台
http://127.0.0.1:8000/course/free/?course_category=1 # 拿课程分类1下的所有课程
'''方式二'''
# 1）自定义过滤类继承django-filter插件的FilterSet类，绑定Model表，并设置分类字段
from django_filters.filterset import FilterSet
from . import models
class CourseFilterSet(FilterSet):
class Meta:
model = models.Course
fields = ['course_category']
# 2）在视图文件views.py中导入django-filter的功能组件及自定义的过滤类
from django_filters.rest_framework import DjangoFilterBackend
from .filters import CourseFilterSet
# 3）将搜索组件配置给群查接口视图类的filter_backends
filter_backends = [DjangoFilterBackend]
# 4）配置视图类关联的自定义过滤类
filter_class = CourseFilterSet
# 5）前台访问该群查接口，采用拼接参数方式用分类course_category字段将分类条件提供给后台
http://127.0.0.1:8000/course/free/?course_category=1 # 拿课程分类1下的所有课程
4.django-filter实现区间过滤
# 1）自定义过滤类继承django-filter插件的FilterSet类，绑定Model表，并设置自定义区间规则字段
from django_filters.filterset import FilterSet
from . import models
class CourseFilterSet(FilterSet):
# 区间过滤: students学生中总人数要大于等于min_students, 要小于等于max_students. [min_students, max_students]
max_students = filters.NumberFilter(field_name='students', lookup_expr='lte')
min_students = filters.NumberFilter(field_name='students', lookup_expr='gte')
class Meta:
model = Course
fields = ['course_category', 'students', 'min_students', 'max_students']
# 2）在视图文件views.py中导入django-filter的功能组件及自定义的过滤类
from django_filters.rest_framework import DjangoFilterBackend
from .filters import CourseFilterSet
# 3）将搜索组件配置给群查接口视图类的filter_backends
filter_backends = [DjangoFilterBackend]
# 4）配置视图类关联的自定义过滤类
filter_class = CourseFilterSet
# 5）前台访问该群查接口，采用拼接参数方式用自定义区间规则字段将区间条件提供给后台
http://127.0.0.1:8000/course/free/?min_students=230&max_students=250 # 获取学生总人数230~250之间的数据
5. 自定义过滤
# filters.py
from rest_framework.filters import BaseFilterBackend
class CustomFilter(BaseFilterBackend):
def filter_queryset(self, request, queryset, view):
# 老师的模糊匹配
name = request.GET.get('teacher')
if not name:
return queryset
teacher_queryset = queryset.filter(teacher__name__contains=name)
return teacher_queryset
# views.py
# 自定义过滤: 通过老师名进行模糊匹配
filter_backends = [CustomFilter]
6. 注意
django-filter的安装可能会出现django版本最低要求问题, 如果下载最新版本的django-filter
如果使用的是django 1.11版本会自动升级到3.x.
# 解决方法：pip install django-filter==2.1.0即可适配django1.11.11
二、排序组件
1. 全局配置/局部配置
# 全局配置
# 排序
REST_FRAMEWORK = {
'DEFAULT_FILTER_BACKENDS': ('rest_framework.filters.OrderingFilter')
}
# 过滤 和 排序
REST_FRAMEWORK = {
'DEFAULT_FILTER_BACKENDS': ('django_filters.rest_framework.DjangoFilterBackend', 'rest_framework.filters.OrderingFilter')
}
# 局部配置
# 排序
from rest_framework.filters import OrderingFilter
filter_backends = [OrderingFilter] # 注意: 如果这样就会覆盖全局配置配置的过滤
# 过滤 和 排序
from rest_framework.filters import OrderingFilter
from django_filters.rest_framework import DjangoFilterBackend
filter_backends = [OrderingFilter, DjangoFilterBackend]
filter_fields = '__all__'
2. 代码示例
class TextView7(ListAPIView):
# 局部将全局可能配置的认证+权限+频率禁用
authentication_classes = []
permission_classes = []
throttle_classes = []
# 局部配置排序组件.
# 注意: 如果要过滤和排序, 需要注意的是如果全局配置了过滤, 需要在声明排序的基础之上再什么过滤. 因为filter_backends的局部指定会覆盖过滤的配置.
# filter_backends = [OrderingFilter, DjangoFilterBackend, ] # 提示: 2者之间没有顺序
filter_backends = [DjangoFilterBackend, OrderingFilter]
queryset = models.Book.objects.all()
serializer_class = BookModelSerializer
filter_fields = ['name', 'price'] # 可以用列表, 也可以用元组
3. 总结
# 过滤导入
from django_filters.rest_framework import DjangoFilterBackend
# 排序导入
from rest_framework.filters import OrderingFilter
# 注意问题
它们2个全局配置都是共用一个配置路径, 如果局部指定了就会将全局配置的对应项所有的覆盖
三、分页组件
1. 分页的三种方式
from rest_framework.pagination import PageNumberPagination
# 第一种分页方式: 通过指定page获取页数, 通过size获取每页显示的条目
class CoustomPageNumberPagination(PageNumberPagination):
"""
url地址栏目支持的查询格式:
http://api.example.org/accounts/?page=4
http://api.example.org/accounts/?page=4&page_size=100
"""
page_size = 3 # 页面大小. 表示显示每页数据条数. 可配置全局('PAGE_SIZE': None)
page_query_param = 'page' # 页面查询参数. 表示查询第几页的key. (可自定义名称)
page_size_query_param = 'size' # 页面大小查询参数. 表示每一页显示的条数 (可自定义名称)
max_page_size = 5 # 最大页面大小. 表示每页最大显示条数
from rest_framework.pagination import LimitOffsetPagination
# 第二种分页方式: 通过指定offset找到指定位置, 通过limit往后获取条目数
class CustomLimitOffsetPagination(LimitOffsetPagination):
"""
url地址栏目支持的查询格式:
http://api.example.org/accounts/?limit=100
http://api.example.org/accounts/?offset=400&limit=100
"""
default_limit = 3 # 每页条数. 可配置全局('PAGE_SIZE': None,)
limit_query_param = 'limit' # 从offset标杆的位置, 往后获取的条目数 (可自定义名称)
offset_query_param = 'offset' # 标杆. 可以理解为旗帜, 插在这里, 后去旗帜后面的内容条目 (可自定义名称)
max_limit = 5 # 每页显示的最大条目数. 默认为None, 不做任何限制.
from rest_framework.pagination import CursorPagination
# 第三种分页方式: 光标分页
class CustomCursorPagination(CursorPagination):
"""
提示: 这种方式实现的方式很复杂, 因此带来的好处就是查询效率极高, 不过也有它的缺陷, 就是通过这种方式制作的分页只有上一页下一页,
如果数据库数据非常大那么使用它将会是非常好的选择.
url地址栏目支持的查询格式:
直接浏览器输入访问即可, 因为不能指定位置.
"""
cursor_query_param = 'cursor' # 每一页查询的key (可自定义名称)
page_size = 3 # 每页显示的条数. 可配置全局('PAGE_SIZE': None,)
ordering = '-id' # 排序字段. 如果不指定默认使用'-created'进行分页, 如果你的数据库中没有这个字段, 那么就会抛出异常
from rest_framework.generics import ListAPIView
from . import ser
from . import models
class BookAPIView(ListAPIView):
queryset = models.Book.objects.all()
serializer_class = ser.BookModelSerializer
"""
APIView -> api_settings -> DEFAULTS -> 51行
# Generic view behavior
'DEFAULT_PAGINATION_CLASS': None,
"""
# pagination_class = CoustomPageNumberPagination
# pagination_class = CustomLimitOffsetPagination
pagination_class = CustomCursorPagination
# 总结
from rest_framework.pagination import PageNumberPagination
通过page分页, 通过site获取分页条目数
from rest_framework.pagination import LimitOffsetPagination
通过offset找到分页位置, 通过limit获取当前数据之后的条目数
from rest_framework.pagination import CursorPagination
没有参数, 默认只有上一页, 下一页. 通过ordering排序进行分页
优点: 查询速度快. 缺点: 无法选择起始位置
提示: 以上都可以限制最大显示条目数 和 默认获取条目数. 以及筛选的key都可以重定义.
2. 如何规范化分页器的restful返回规范
from rest_framework.generics import ListAPIView
from utils.response import CommonResponse
from utils.throttle import CustomSimpleRateThrottle
from . import ser
from . import models
class BookAPIView(ListAPIView):
queryset = models.Book.objects.all()
serializer_class = ser.BookModelSerializer
throttle_classes = [CustomSimpleRateThrottle, ]
def get(self, request, *args, **kwargs):
instance = self.get_queryset()
# 调用分页器, 实例化出分页器对象
page_obj = CustomCursorPagination()
# 此处的instance要和上面的查询集一样
instance = page_obj.paginate_queryset(queryset=instance, request=request, view=self)
# 通过分页器对象. 获取下一条的url链接
next_url = page_obj.get_next_link()
# 通过分页器对象. 获取上一条的url链接
previous_url = page_obj.get_previous_link()
# print('next_url:', next_url)
# print('previous_url:', previous_url)
serializer = self.get_serializer(instance=instance, many=True)
return CommonResponse(results=serializer.data, next_url=next_url, previous_url=previous_url)
# 总结
# 1. 调用分页器, 实例化出分页器对象
page_obj = CustomCursorPagination()
# 2. 通过分页器对象. 获取下一条的url链接 (注意: 一下获取都在序列化之后)
next_url = page_obj.get_next_link()
# 3. 通过分页器对象. 获取上一条的url链接
previous_url = page_obj.get_previous_link()
# 补充: 通过自定义类继承分页类, 就可以实现修改参数了, 如果像上面一样那么就不能自定义一些参数了
default_limit = 3
limit_query_param = 'limit'
offset_query_param = 'offset'
max_limit = 5
四、异常处理
1. 从源码分析到如何实现
# 思路: 发现有些错误被drf捕获了, 而有些错误会交给django自己处理, 这是为什么呢? 源码分析一波
# 查找路径: APIView -> dispatch -> try..except -> handle_exception
# 源码分析:
try:
self.initial(request, *args, **kwargs)
# Get the appropriate handler method
if request.method.lower() in self.http_method_names:
handler = getattr(self, request.method.lower(),
self.http_method_not_allowed)
else:
handler = self.http_method_not_allowed
response = handler(request, *args, **kwargs)
except Exception as exc:
response = self.handle_exception(exc) # 这里
1. 异常的捕获范围: 注意, 并不是所有位置的异常出可以捕获. 例如: 自定义视图中的类中抛出的异常就不行
self.initial(request, *args, **kwargs)
认证: self.perform_authentication(request)
提示: 不会捕获自定义的认证类. 因此perform_authentication做的事情就是request.user赋值
权限: self.check_permissions(request)
频率: self.check_throttles(request)
自定义视图类中的方法:
response = handler(request, *args, **kwargs)
2. 关键实现 handle_exception方法
def handle_exception(self, exc):
# 1) 这里的在认证失败的时候会走
if isinstance(exc, (exceptions.NotAuthenticated,
exceptions.AuthenticationFailed)):
# WWW-Authenticate header for 401 responses, else coerce to 403
auth_header = self.get_authenticate_header(self.request)
if auth_header:
exc.auth_header = auth_header
else:
exc.status_code = status.HTTP_403_FORBIDDEN
# 2) 这里就是通过配置文件配置的路径, 拿到处理异常的函数, 内部就一句代码: self.settings.EXCEPTION_HANDLER
'''
def get_exception_handler(self):
"""
配置文件导入的内容:
'EXCEPTION_HANDLER': 'rest_framework.views.exception_handler',
"""
return self.settings.EXCEPTION_HANDLER
'''
exception_handler = self.get_exception_handler()
# 3) 获取异常的处理的上下文内容, 本质里面就是获取操作的视图对象的结果
'''
def get_exception_handler_context(self):
return {
'view': self,
'args': getattr(self, 'args', ()),
'kwargs': getattr(self, 'kwargs', {}),
'request': getattr(self, 'request', None)
}
'''
context = self.get_exception_handler_context()
# 4) 将刚刚从配置文件中导入的视图函数传参调用
'''
exc: 这里的exc是APIView中定义的dispatch中传过来的异常对象
context: 这里的context是对出现异常对象的上下文捕获
'''
response = exception_handler(exc, context)
# 5) 关键转折:
'''
这里就是通过在drf提供的exception_handler函数处理的返回值结果来判断时候交给django自己处理.
如果response的返回值是None就会交给django处理了, 现在我们要的就是在exception_handler函数执行完毕以后将返回值进行判断,
并且返回的结果不再是None, 而应该是response对象
'''
if response is None:
self.raise_uncaught_exception(exc)
response.exception = True
return response
# 步骤:
1. 先新建一个.py文件存放自定义的异常处理函数
2. 在drf提供的默认配置文件中导入exception_handler函数的
3. 在自定义异常处理函数中先将exception_handler传入让drf先处理一番, 根据返回的结果为None是来执行自己的判断.
如果返回不为None也不应该直接将原本的response对象直接返回, 可以自己封装一个符合restful规范的类用来继承Response类
将原本的response对象中的返回结果通过 response.data.get('detail') 方法获取
4. settings.py文件中配置自定义的exception_handler函数的路径
'EXCEPTION_HANDLER': 'app01.app_auth.custom_exception_handler',
2. 代码示例
from rest_framework.views import exception_handler
from rest_framework import status
from rest_framework.response import Response
class APIResponse(Response):
def __init__(self, code=1000, messages='成功', results=None, error=None,
status=None,
template_name=None, headers=None,
exception=False, content_type=None, **kwargs):
data = {
'code:': code,
'messages:': messages,
}
print('error:', error)
print('results:', results)
if results:
data['results'] = results
if error:
data['error'] = error
data.update(kwargs)
super().__init__(data=data, status=status,
template_name=template_name, headers=headers,
exception=exception, content_type=content_type)
def custom_exception_handler(exc, context):
"""
:param exc: 这里的exc是APIView中定义的dispatch中传过来的异常对象
try:
...
except Exception as exc:
response = self.handle_exception(exc)
:param context: 这里的context是对出现异常对象的上下文捕获
查找: handle_exception -> get_exception_handler_context
def get_exception_handler_context(self):
return {
'view': self,
'args': getattr(self, 'args', ()),
'kwargs': getattr(self, 'kwargs', {}),
'request': getattr(self, 'request', None)
}
:return: 这里返回Response对象, 本来drf没有处理的的异常会交给django处理, 但是我们捕获这种异常, 规定成统一的处理. 让drf处理.
注意!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
这里可以捕获的异常范围由以下源码得知:
try:
self.initial(request, *args, **kwargs)
# Get the appropriate handler method
if request.method.lower() in self.http_method_names:
handler = getattr(self, request.method.lower(),
self.http_method_not_allowed)
else:
handler = self.http_method_not_allowed
response = handler(request, *args, **kwargs)
except Exception as exc:
response = self.handle_exception(exc)
捕获范围:
self.initial(request, *args, **kwargs)
认证: self.perform_authentication(request)
提示: 不会捕获自定义的认证类. 因此perform_authentication做的事情就是request.user赋值
权限: self.check_permissions(request)
频率: self.check_throttles(request)
自定义视图类中的方法:
response = handler(request, *args, **kwargs)
"""
obj = None
response = exception_handler(exc, context)
# 注意: exc, context都不是可json序列化的格式, 需要转换成字符串类型.
if not response:
# 自己的处理
if isinstance(exc, AttributeError):
obj = APIResponse(2000, '失败', error=str(exc), results=str(context), status=status.HTTP_403_FORBIDDEN)
elif isinstance(exc, ImportError):
obj = APIResponse(2002, '失败', error=str(exc), results=str(context), status=status.HTTP_403_FORBIDDEN)
elif isinstance(exc, TypeError):
obj = APIResponse(2003, '失败', error=str(exc), results=str(context), status=status.HTTP_403_FORBIDDEN)
elif isinstance(exc, Exception):
obj = APIResponse(2004, '失败', error=str(exc), results=str(context), status=status.HTTP_403_FORBIDDEN)
else:
# 在drf处理的基础之上再次处理
obj = APIResponse(2005, '失败', error=response.data.get('detail'), results=str(context),
status=status.HTTP_403_FORBIDDEN)
return obj
3. 注意
配置文件中配置自定义的异常处理函数时, drf提供的exception_handler的导入会与在同一个文件中自定义的认证类 或者 自定义的权限类的导入起冲突.
自定义的异常的处理代码逻辑最好新建一个纯净的.py文件存放
4. 快速使用
from rest_framework.views import exception_handler
from rest_framework.response import Response
class CommonResponse(Response):
def __init__(self, code=1000, messages='ok', results=None,
status=None, template_name=None, headers=None,
exception=False, content_type=None,
**kwargs):
data = {
'code': code,
'messages': messages,
}
data.update(kwargs)
if results:
data['results'] = results
super().__init__(data=data, status=status,
template_name=template_name, headers=headers,
exception=exception, content_type=content_type)
def common_exception_handler(exc, context):
response = exception_handler(exc, context)
if not response:
obj = CommonResponse(code=2000, messages='error', results=str(exc))
else:
obj = CommonResponse(code=2000, messages='error', results=response.data.get('detail'))
return obj
5. 总结
1. 导入需要在drf提供的默认函数的基础之上的函数
from rest_framework.views import exception_handler
2. 自定义异常处理函数2个参数exc, context
3. 先让drf处理一波, 处理它处理不完的, 或者 在他处理完的基础之上拓展, 通过response返回结果来进行区分
提示: 可以通过 response.data.get('detail') 获取drf处理完的对象中返回的响应信息
