Django Rest Framework 教程及API向导

Django Rest Framework 教程及API向导。

1、请求（Request）
REST_FRAMEWORK 中的 Request 扩展了标准的HttpRequest,为 REST_FRAMEWORK增长了灵活的request解析和request认证。
一、请求
.data: 获取请求的主体，至关于request.POST和request.FILES
.query_params:   request.GET的重命名
.parsers:   APIView类或@api_view装饰将确保这个属性将自动设置为一个解析器实例列表
二、内容协商
.accepted_render: 接受渲染一个对象内容协商
.accepted_media_type: 接受的媒体类型
三、身份验证
.user:  一般返回django.contrib.auth.models.user的对象。虽然行为取决于所使用的身份验证策略。
若是请求用户没有被认证，request.user是一个django.contrib.auth.models.Anoymoser对象。
.auth:  被认证的后才会被使用，返回任何额外身份的环境。
.authenticators:  APIView类或@api_view装饰将确保这个属性将自动设置为一个认证明例列表
四、浏览器加强方法
django rest framework提供一些附加的表单提交方法:PUT,PATCH,DELETE
.method: 返回一个大写的HTTP请求方法字符串，包含了PUT,PATCH,DELETE等。
.content_type: 返回一个字符串对象表明HTTP请求的媒体类型的身体,或若是没有媒体类型提供一个空字符串。
一样可使用：request.META.get(‘HTTP_CONTENT_TYPE’)
.stream: 返回一个请求主体类容的流。
五、 支持其余标准的HttpResquest属性
.META/.session/等等
2、Response（响应）
你须要使用一个APIView类或@api_view函数返回response对象的views
一、建立Response
from rest_framework.response import Response
例: Response(data, status=None, template_name=None, headers=None, content_type=None)
data: 响应serialized(序列化)后的数据
status: 定义响应状态码，默认200
template_name: 若是HTMLRender被选择，返回一个模板
headers: 是关于HTTP请求头的一个字典
content_type: 响应内容类型，通常会根据内容自动协商。
二、其余标准的HttpResponse属性
response = Response()
response[‘Cache-Control’] = ‘no-cache’
.render(): 响应序列化的数据。
3、基本视图类 (APIView/@api_view)
一、类基础视图（APIView）
DRF不一样于django常规的view类，他有以下几点优势：
* 提供了更好用的request对象，不一样于普通的django HttpRequest更好用。
* 封装了Response对象，代替了原有的django HttpResponse，视图将管理内容协商并设置正确的渲染器的响应。
* 任何APIException异常将会被捕捉，并作适当的响应。
* 传入的请求将身份验证和适当的权限和节流检查将以前运行调度请求处理程序的方法。
一个小例子：

 

from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework import authenication, permissions

class ListUser(APIView):
“””

展现系统中全部的用户
* 须要令牌认证。
* 只有admin用户可以访问这一个视图

"""
authentication_classes = (authentication.TokenAuthentication,)  # 认证策略属性
permission_classes = (permissions.IsAdminUser,) # 权限策略属性

def get(self, requeset, format=None):
"""
返回一个用户列表
"""
usernames = [user.username for user in  User.objects.all()]
return Response(usernames)

1） API策略属性
如下的API策略属性应用于APIView，控制视图的策略：
renderer_classes： 渲染器类
parser_classes： 解释器类
authentication_classes： 权限类
throttle_classes：节流类
permission_classes： 权限类
content_negotiation_class： 内容协商类
2）API 策略方法
如下的策略方法用在API的策略，一般不用重写它：
get_renderers(self):  获取渲染器方法
get_parsers(self): 获取解释器方法
get_authenticators(self): 或缺认证方法
get_throttles(self): 获取节流方法
get_permissions(self):  获取权限方法
get_content_negotiator(self): 获取内容协商方法
3）API策略实施方法
下列方法以前被称为调度处理程序方法：
check_permissions(self, request): 检查权限
check_throttles(self, request): 检查节流
check_content_negotiation(self, request, force=False): 检查内容协商
4）调度方法
这些执行任何操做,须要发生以前或以后调用处理程序方法等.
initial(self, request, *args, **kwargs): 执行任何操做,须要发生在处理程序方法以前被调用。这个方法是用来执行权限和节流,并执行内容协商。
handle_exception(self, exc)：抛出的任何异常处理程序方法将被传递给这个方法,而返回响应实例,或者re-raises异常。
initialize_request(self, request, *args, **kwargs)：确保请求对象传递给处理程序方法是request的一个实例，而不是django的HttpRequest
finalize_response(self, request, response, *args, **kwargs)：确保任何响应处理程序方法返回的对象将被呈现到正确的内容类型
二、函数基础视图（@api_view()）
DRF一样提供了另一种函数基础视图来装饰django的普通视图，咱们一样可使用request来接受请求和response响应。
一个小例子：

from rest_framework.decorators import api_view

@api_view
def hello_world(request):
return Response({“message”:”Hello world!”})

1）api_view()使用方法
这个视图将使用默认渲染器、解析器、身份验证设置中指定的类等。一般默认只有GET方法，其余请求方法会报405错误，咱们能够手动添加方法为这
装饰器指定request方法。像这样：

@api_view([‘GET’, ‘POST’])
def hello_world(request):
if request.method  == ‘POST’:
return Response({“message”:”Got some data”, “data”: request.data})
return Response({“messsage”:”Hello world!”})

2）API策略装饰器
DRF提供了不少附加的装饰器，咱们能够添加到@api_view()后面，例如要加入一个节流的装饰器来确保特定用户天天只能一次经过这个视图，我
咱们就要用到@throttle_classes装饰器：

from rest_framework.decorators import api_view, throttle_classes
from rest_framework.throttling import UserRateThrottle

class OncePerDayUserThrottle(UserRateThrottle):
rate = “1/day”

@api_view([‘GET’])
@throttle_classes([OncePerDayUserThrottle])
def view(request):
return Response({“message”:”Hello for to day! see you tomorrow!”})

其余可用API的装饰器：
@renderer_classes(…)
@parser_classes(…)
@authentication_classes(…)
@throttle_classes(…)
@permission_classes(…)
4、 通用视图（Generic views）
基于类视图的主要好处之一是他们容许您编写可重用的行为.
REST框架提供的通用视图容许您快速构建API观点紧密地映射到您的数据库模型.
若是通用视图不适合你的须要API,您可使用常规APIView类,或重用mixin和基类使用的通用视图来组成本身的组可重用通用视图。
一、通用视图
一样咱们能够设置一些类属性在通用视图内，也能够根据特殊要写重写它的内部视图方法。一个小例子：

from django.contrib.auth.models import User
from myapp.serializers import UserSerializer
from rest_framework import generics
from rest_framework.permissions import IsAdminUser

class UserList(generics.ListCreateAPIView):
queryset = User.objects.all()
serializer_class = UserSerializer
permission_classes = (IsAdminUser,)

def list(self, request):
# Note the use of get_queryset() instead of self.queryset
queryset = self.get_queryset()
serializer = UserSerializer(queryset, many=True)
return Response(serializer.data)

在urls配置中，咱们可使用.as_views()来转换成视图函数，固然也能够配置一些属性

url(r’^/users/’, ListCreateAPIView.as_view(queryset=User.objects.all(), serializer_class=UserSerializer), name=’user-list’)

二、GenericAPIView通用视图API参考：
GenericAPIView继承了DRF的APIView类，为list和detail视图增长了一些通常需求行为方法（提供queryset）。
1）属性
基本属性：
queryset: 用于返回query对象集合，也可使用get_queryset()方法。
serializer_class: 序列化器类,应该用于输入进行验证和反序列化,并用于序列化输出。一般状况下,你必须设置这个属性,或重写get_serializer_class()方法。
lookup_field: 模型的字段应该用于执行对象查找个别的模型实例
ookup_url_kwarg:URL应该用于对象查找关键字参数

分页属性：
pagination_class: 用于返回一个分页列表视图的分页类，默认与settings中设置的DEFAULT_PAGINATION_CLASS 值相同，
能够经过’rest_framework.pagination.PageNumberPagination’设置分页数
过滤器属性：
filter_backends: 过滤queryset的类列表，和在settings中设置DEFAULT_FILTER_BACKENDS 同样
2）方法
基本方法：
get_queryset(): 返回queryset。（详情见官网http://www.django-rest-framework.org/api-guide/generic-views/）
get_object():获取某一个具体的model实例对象。
保存与删除挂钩方法：
如下方法是mixins类提供，提供简单的对象保存和删除的行为重写：
perform_create(self, serializer): CreateModelMixin 当要保存对象时候会被调用
perform_update(self, serializer):UpdateModelMixin 当要更新对象时候会被调用
perform_destroy(self, instance): DestoryModelMixin 当药删除对象时候会被调用
三、Mixins
mixin类提供用于提供基础视图的操做行为。注意,mixin类提供操做方法而不是定义处理程序方法,好比. get()和. post(),直接。这容许更灵活的组合的行为。
经过rest_framework.mixins引用。
ListModelMixin：提供list方法，列出queryset
CreateModelMixin： 提供create方法，建立和保存一个Model对象
RetrieveModelMixin：提供retrieve方法，检索一个存在的model对象
UpdateModelMixin： 提供Update方法，更改一个模型对象
DestroyModelMixin：提供destroy方法，删除一个模型对象
4）Generic
Generic通用视图类提供具体操做的通用视图类，能够理解为Generic.GenericAPIView和mixin类的合体，经过rest_framework.generic.调用
.CreateAPIView:
建立一个模型实例
提供post方法的处理器
继承于：GenericAPIView，CreateModelMixin
.ListAPIView:
模型实例的集合
提供get方法处理器
继承于：GenericAPIView，ListModelMixin
.RetrieveAPIView:
一个模型实例
提供get方法处理器
继承于：GenericAPIView，RetrieveModelMixin
.DestoryAPIView:
删除一个模型实例
提供delete方法处理器
继承于：GenericAPIView，DestroyModelMixin
.UpdateAPIView:
修改模型实例，
提供put和patch方法处理器
继承于：GenericAPIView，UpdateModelMixin
.ListCreateAPIView:
建立和展现一个模型实例集合
提供get和post处理器
继承于：GenericAPIView，ListModelMixin，CreateModelMixin
.RetrieveUpdateAPIView:
读和改一个模型实例
提供get,put,patch处理器
继承于：GenericAPIView，RetrieveModelMixin，UpdateModelMixin
.RetrieveDestoryAPIView:
读和删除一个模型实例
提供get和delete处理器
继承于：GenericAPIView，RetrieveModelMixin，DestroyModelMixin
.RetrieveUpdateDestroyAPIView：
读、改和删一个模型实例
get, put, patch,delete处理器
继承于：GenericAPIView，RetrieveModelMixin，UpdateModelMixin，DestroyModelMixin
5、视图集合ViewSets
Django REST框架容许您将一组相关的逻辑视图在一个类，ViewSet类是一个简单类型的基于类的观点,没有提供任何方法处理程序如.get()或. post(),
而代替提供方法好比.list()和create()。
一个小例子：

 

from django.contrib.auth.models import User
from django.shortcuts import get_object_or_404
from myapps.serializers import UserSerializer
from rest_framework import viewsets
from rest_framework.response import Response

class UserViewSet(viewsets.ViewSet):
“””
A simple ViewSet for listing or retrieving users.
“””
def list(self, request):
queryset = User.objects.all()
serializer = UserSerializer(queryset, many=True)
return Response(serializer.data)

def retrieve(self, request, pk=None):
queryset = User.objects.all()
user = get_object_or_404(queryset, pk=pk)
serializer = UserSerializer(user)
return Response(serializer.data)

1）关于ViewSets
若是咱们须要，咱们须要为两个GET请求分开绑定视图：
user_list = UserViewSet.as_view({“GET”:’list’})
user_detail = UserViewSet.as_view({‘GET’:’retrieve’})

可是一般咱们不会这样作，而是经过注册路由来配置url：

from myapp.views import UserViewSet
from rest_framework.routers import DefaultRouter
router = DefaultRouter()
router.register(r’users’, UserViewSet)
urlpatterns = router.urls

或许你会常常用到本身模型数据，而不是手动写视图集合，这样就要用到模型视图集合ModelViewSet:

class UserViewSet(viewsets.ModelViewSet):
“””
A viewset for viewing and editing user instance
“””
serializer_class = UserSerializer
queryset = User.objects.all()

其余路由函数方法：

class UserViewSet(viewsets.ViewSet):
“””
Example empty viewset demonstrating the standard
actions that will be handled by a router class.

If you’re using format suffixes, make sure to also include
the format=None keyword argument for each action.
“””

def list(self, request):
pass

def create(self, request):
pass

def retrieve(self, request, pk=None):
pass

def update(self, request, pk=None):
pass

def partial_update(self, request, pk=None):
pass

def destroy(self, request, pk=None):
pass
若是你有特别的须要被路由到的方法,能够将它们标记为须要路由使用@detail_route或@list_route修饰符。
@detail_route(methods=[‘post’], permission_classes=[IsAdminOrIsSelf])
def set_password(self, request, pk=None):
…
能够经过访问^users/{pk}/set_password/$来访问改视图

2）ViewSets的API参考
.ViewSet：
继承了APIView，你可使用一些标准的属性例如permission_class,authentication_classes去对视图作一些策略。ViewSet一样不提供具体
行为方法的实现，你能够重写和定义一些请求处理方法。而代替了原来APIVIew的POST，GET等方法，取而代之的是list，create等方法。
.GenericViewSet:
继承了GenericAPIView，提供了默认的get_queryset()和get_object()等方法来获取model数据，但不提供任何请求处理方法。
.ModelViewSet:
继承了GenericAPIView，增长了一些请求处理方法，如list(), retrieve(),create()等。
例子：

 

class AccountViewSet(viewsets.ModelViewSet):
“””
A simple ViewSet for viewing and editing accounts
“””
queryset = Account.objects.all()
serializer_class = AccountSerializer
permissions_classes = [IsAccountAdminOrReadOnly]

.ReadOnlyModelViewSet:
继承了GenericAPIView，只增长了只读的请求处理方法list()和retrieve()
自定义View类：
只须要继承GenericAPIView, 增长mixins的相关处理方法。如：

 

class CreatListRetrieveViewSet(mixins.CreateModelMixin,
mixins.ListModelMixin,
mixins.RetrieveModelMixin,
View.GenericViewSet):
pass

6、路由(routers)
一、REST框架还支持自动Django URL路由,并为您提供了一个简单的、快速的和一致的方式链接视图逻辑的URL。
若是设置basename将自动生成基于queryset viewset的属性,若是它有一个。注意,若是viewset不包括queryset属性而后注册时必须设置base_name viewset。

 

from rest_framework import routers
router = routers.SimpleRouter()
router.register(r’users’, UserViewSet, ‘users’)
router.register(r’accounts’, AccountViewSet)
urlpatterns = router.urls
注意：router.register有三个参数属性：
*prefix：这是url匹配正则表达式。
*viewset: 指定视图集合
*base_name: 基于基础的url名字设置。这个特别要注意，若是不加这个参数，那么视图集合必需要包含queryset这个属性。

二、使用路由routers

router = routers.SimpleRouter()
router.register(r’users’, UserViewSet)
urlpatterns = [
url(r’^api/’, include(router.urls, namespace=’api’)),
]
或者：urlpatterns +=router.urls

三、@detail_route / @list_route指定路由
@detail_route(methods=[‘post’], permission_classes=[IsAdminOrIsSelf])
->指定post方法，权限为IsAdminOrIsSelf
7、解释器(parse)
一、设置解释器
设置成全局：

REST_FRAMEWORK ={
‘DEFAULT_PARSER_CLASSES’: (‘rest_framework.parsers.JSONParser’,）
}

也能够在视图APIView中设置：

from rest_framework.parsers import JSONParser
parser_class = (JSONParser,)

若是是@api_view装饰的视图：
@api_view([‘POST’])
@parser_classes((JSONParser,))

二、API 参考
JSONParse: application/json
FormParse: application/x-www-form-urlencoded
MultiPartParser:  multipart/form-data
FileUploadParser: */*
–>file_obj = request.data[‘file’]
8、渲染器(renders)
一、设置渲染器
设置成全局：

 

REST_FRAMEWORK ={
‘rest_framework.renderers.JSONRenderer’,
‘rest_framework.renderers.BrowsableAPIRenderer’,
}

也能够在视图APIView中设置：

from rest_framework.renderers import JSONRenderer
renderer_classes = (JSONRenderer, )
若是是@api_view装饰的视图：
@api_view([‘GET’])
@renderer_classes((JSONRenderer,))

9、序列化器serializers
序列化器能够将python的复杂数据格式渲染成json，xml等格式，同时也提供了反序列化器，能够将渲染成的数据解释成python的数据模型对象。它和django中
的from表单用法很类似。
一、渲染序列化对象：
能够将对象序列化成json,xml格式等

 

serializer = CommentSerializer(comment)
serializer.data
# {’email’: ‘leila@example.com’, ‘content’: ‘foo bar’, ‘created’: ‘2016-01-27T15:17:10.375877′}

json = JSONRenderer().render(serializer.data)  # 渲染成json格式
# b'{“email”:”leila@example.com”,”content”:”foo bar”,”created”:”2016-01-27T15:17:10.375877″}’

二、反序列化

 

from django.utils.six import BytesIO
from rest_framework.parsers import JSONParser

stream = BytesIO(json)
data = JSONParser().parse(stream)   # 解析json格式

serializer.is_valid()
# True
serializer.validated_data

三、保存实例
能够利用.create()和.update()方法
调用.save()方法会执行上面两个方法，自动保存或者更新实例对象
有时候，须要保存其余的信息，能够在参数中添加，如：
serializer.save(owner=request.user)
四、验证validation
当须要保存反序列化的数据时，咱们每每须要在以前用is_valid()验证数据的合法性，若是不合法能够用
serializer.errors获得该错误信息。这个错误信息能够根据error_message来进行自定义
五、模型序列化ModelSerializer
模型序列化与字段序列化用法相似，只需在类的属性Meta中指定相应的模型，就会根据模型自动生成相应的字段
class AccountSerializer(serializers.ModelSerializer):
class Meta:
model = Account
fields = (‘id’, ‘account_name’, ‘users’, ‘created’)
六、超连接模型序列化HyperlinkedModelSerializer
与模型序列化相似，只不过过了一个可连接的形式。
10、序列化字段serializer fields
一、核心参数
*read_only: 只读形式，只能序列化到api输出，不能被反序列化数据更新修改操做。默认False
*wirte_only: 只写形式，只能被反序列化数据更新和建立，不能序列化表示。默认False
*required: 必须字段，一般出如今反序列化的过程当中，该字段必须有值。默认True
*allow_null：是否容许为空，默认False
*default: 默认值，
*source：字段来源，为字段指定一个字段来源，如(source=’user.email’).
*validators: 合法性函数列表，支持django的ValidationError包。
*error_message: 一个错误信息的字典，包含null, blank, invalid, invalid_choice, unique等键值。
*label:一篇简短的文本字符串,能够用做在HTML表单字段的名称或其余描述性的元素
*help_text: 一个文本字符串,能够用做描述字段的HTML表单字段或其余描述性的元素。
*initial: 用于预先填充HTML表单字段的值。
*style: 字典的键-值对,能够用来控制渲染器应该如何呈现。
二、字段类型
*布尔字段BooleanField: BoolenField(defalut=True)
*字符字段StringField: CharField(max_length=None, min_length=None, allow_blank=False, trim_whitespace=True)
*邮箱字段EmailField: EmailField(max_length=None, min_length=None, allow_blank=False)
*正则字段RegexField: RegexField(regex, max_length=None, min_length=None, allow_blank=False)
*新闻标题字段SlugField：SlugField(max_length=50, min_length=None, allow_blank=False)
*URL地址字段 UrlField: URLField(max_length=200, min_length=None, allow_blank=False)
*UUID字段 UUIDField: UUIDField(format=’hex_verbose’)   —“de305d54-75b4-431b-adb2-eb6b9e546013″
*文件路径字段FilePathField：FilePathField(path, match=None, recursive=False, allow_files=True, allow_folders=False, required=None, **kwargs)
*IP地址字段IPAddressField：IPAddressField(protocol=’both’, unpack_ipv4=False, **options)
*数字型字段：IntegerField、FloatField、DecimalField
*时间和日期字段：DateTimeField：DateTimeField(format=None, input_formats=None)
DateField：
TimeField：
DurationField：
*选择字段：ChoiceField
*文件字段：FileField：FileField(max_length=None, allow_empty_file=False, use_url=UPLOADED_FILES_USE_URL)
ImageField：ImageField(max_length=None, allow_empty_file=False, use_url=UPLOADED_FILES_USE_URL)
*模型字段：ModelField：ModelField(model_field=<Django ModelField instance>)
*只读字段：ReadOnlyField：
11、字段关系serializer relations
多对一：ForeignKey
多对多: ManyToManyField
一对一：OneToOneField
一、api参考
tracks = serializers.StringRelatedField(many=True)  # 字符串形式关系字段
tracks = serializers.PrimaryKeyRelatedField(many=True, read_only=True)# 主键形式关系字段
tracks = serializers.HyperlinkedRelatedField(many=True, read_only=True, view_name=’track-detail’) # 超连接形式关系字段
tracks = serializers.SlugRelatedField(many=True, read_only=True, slug_field=’title’)  # 以小标题形式关系
track_listing = serializers.HyperlinkedIdentityField(view_name=’track-list’)  # 超连接身份关系
二、嵌套关系
序列化类中能够直接引用其余序列化化类
12、合法性验证(Validation)
一、数据的惟一性UniqueValidator
在模型中，只需设置字段的unique=True就会在该字段自动生成改惟一性判断
例:slug = SlugField(max_length=100, validators=[UniqueValidator(queryset=BlogPost.objects.all(), messsage=”)])
*queryset：模型数据对象集合
*message: 异常提示信息
二、数据字段的不重复性UniqueTogetherValidator

 

class Meta:
validators = [
UniqueTogetherValidator(
queryset=ToDoItem.objects.all(),
fields=(‘list’, ‘position’)
)
]
*queryset：模型数据对象集合
*fields: 字段的集合元祖
*message: 异常提示信息

 

十3、认证Authentication
一、设置认证方案
*能够在settings文件中配置DEFAULT_AUTHENTICATION_CLASSES：

 

REST_FRAMEWORK = {
‘DEFAULT_AUTHENTICATION_CLASSES’: (
‘rest_framework.authentication.BasicAuthentication’,
‘rest_framework.authentication.SessionAuthentication’,
)
}

*也能够在视图中设置
(APIView)：

authentication_classes = (SessionAuthentication, BasicAuthentication)
permission_classes = (IsAuthenticated,)
(@api_view)
@authentication_classes((SessionAuthentication, BasicAuthentication))
@permission_classes((IsAuthenticated,))

十4、权限
一、设置权限方案
*能够在settings文件中配置DEFAULT_PERMISSION_CLASSES

 

REST_FRAMEWORK = {
‘DEFAULT_PERMISSION_CLASSES’: (
‘rest_framework.permissions.IsAuthenticated’,
# ‘rest_framework.permissions.AllowAny’,
)
}

*视图中设置：
（APIView）

 

permission_classes = (IsAuthenticated,)
（@api_view）
@permission_classes((IsAuthenticated, ))

二、API引用
*AllowAny：容许任何
*IsAuthenticated：是否被认证
*IsAdminUser：是管理用户
*IsAuthenticatedOrReadOnly：是被认证或者只读
*DjangoModelPermissions：标准的django模型设置权限
*DjangoModelPermissionsOrAnonReadOnly：标准的django模型处理或者只读权限
*DjangoObjectPermissions：相比模型权限，只提供queryset和get_queryset方法。
*自定义权限：
继承BasePermission;
重写：.has_permission(self, request, view)
.has_object_permission(self, request, view, obj)
十5、节流Trottling
限制请求量
一、设置节流方案
*能够在settings文件中配置DEFAULT_THROTTLE_CLASSES 和 DEFAULT_THROTTLE_RATES

 

‘DEFAULT_THROTTLE_CLASSES’: (
‘rest_framework.throttling.AnonRateThrottle’,
‘rest_framework.throttling.UserRateThrottle’
),
‘DEFAULT_THROTTLE_RATES’: {
‘anon’: ‘100/day’,
‘user’: ‘1000/day’
}

*能够在视图中设置：
（APIView）

 

throttle_classes = (UserRateThrottle,)
（@api_view）
@throttle_classes([UserRateThrottle])

十6、过滤器Filtering
一般drf的默认的通用list视图类要处理的是所有模型的查询集合集，若是咱们要指定结果集，
这就必须用到过滤器了。一般的方法是重写get_queryset(self)方法。
例如：
# 根据用户过滤

 

class PurchaseList(generics.ListAPIView):
serializer_class = PurchaseSerializer

def get_queryset(self):
user = self.request.user
return Purchase.objects.filter(purchase = user)
# 根据url请求过滤
def get_queryset(self):
username = self.kwargs[‘username’]
return Purchase.objects.filter(purchaser__username=username)
# 根据请求参数过滤同上
def get_queryset(self):
queryset = Purchase.objects.all()
username = self.request.query_params.get(‘username’, None)
if username is not None:
queryset = queryset.filter(purchaser__username=username)
return queryset

一、generic filter过滤
*经过settings文件中配置过滤

 

REST_FRAMEWORK = {
‘DEFAULT_FILTER_BACKENDS’: (‘rest_framework.filters.DjangoFilterBackend’,)
}

*也可经过视图中过滤
filter_backends = (filters.DjangoFilterBackend,)

 

二、API向导
*pip install django-filter
filter.DjangoFilterBackend

*filter_fields过滤字段

 

class ProductList(generics.ListAPIView):
query = Product.object.all()
serializer_class = ProductSerializer
filter_backends = (filter.DjangoFilterBackend,)
filter_fields = (‘category’, ‘in_stock’)
http://example.com/api/products?category=clothing&in_stock=True
*filter_class指定一个过滤集合类
import django_filters
from myapp.models import Product
from myapp.serializers impoert ProductSerializer
from rest_framework import filters
from rest_framework import generics

class ProductFilter(filters.FilterSet):
min_price = django_filters.NumberFilter(name=’price’, lookup_type=”gte”)
max_price = django_filters.NumberFilter(name=’price’, lookup_type=”lte”)

class Meta:
model = Product
fields = [‘category’, ‘in_stock’, ‘min_price’, ‘max_price’]

class ProductList(generics.ListAPIView):
queryset = Product.object.all()
serializer_class = ProductSerializer
filter_backends = (filter.DjangoFilterBackend,)
filter_class = ProductFilter
http://example.com/api/products?category=clothing&max_price=10.00

同理双下划线强调名字：
class ProductFilter(filters.FilterSet):
class Meta:
model = Product
fields = [‘category’, ‘in_stock’, ‘manufacturer__name’]
http://example.com/api/products?manufacturer__name=foo
上面例子等同于：
class ProductFilter(filter.FilterSet):
manufacturer = django_filters.CharFilter(name=”manufacter__name”)

class Meta:
model = Product
fields = [‘category’, ‘in_stock’, ‘manufacturer’]
http://example.com/api/products?manufacturer=foo
*search_fields 搜索字段
class UserListView(generics.ListAPIView):
queryset = User.object.all()
serializer = UserSerializer
filter_backends = (filter.SearchFilter,)
filter_fields = (“suername”, ’email’)
http://example.com/api/users?search=russell

*ordring_fields排序字段
class UserList(generics.ListAPIView):
queryset = User.object.all()
serializer_class = UserSerializer
filter_backends = (filter.OrderingFilter,)
filter_fields = ‘__all__’
ordering = (‘username’,)  # 默认排序字段
*DjangoOjectPermissionFilter 对象权限的过滤器
filter_backends = (filter.DjangoObjectPermissionFilter,)
permission_classes = (myapp.permissions.CustomObjectPermissions,)  # 自定义的权限类

十7、分页Pagination
一、设置分页
*能够在settings中设置分页样式

 

REST_FRAMEWORK = {
‘DEFAULT_PAGINATION_CLASS’: ‘rest_framework.pagination.LimitOffsetPagination’
}

*修改分页样式

 

class LargeResultsSetPagination(PageNumberPagination):
page_size = 1000
page_size_query_param = ‘page_size’
max_page_size = 10000

class StandardResultsSetPagination(PageNumberPagination):
page_size = 100
page_size_query_param = ‘page_size’
max_page_size = 1000

*应用到视图中

 

class BillingRecordsView(generics.ListAPIView):
queryset = Billing.objects.all()
serializer = BillingRecordsSerializer
pagination_class = LargeResultsSetPagination

2) API引用
*PageNumberPagination
设置全局的分页大小：

 

REST_FRAMEWORK = {
‘DEFAULT_PAGINATION_CLASS’: ‘rest_framework.pagination.PageNumberPagination’,
‘PAGE_SIZE’: 100
}