特点:
提供了定义序列化器Serializer的方法,可以快速根据 Django ORM 或者其它库自动序列化/反序列化;
丰富的定制层级:函数视图、类视图、视图集合到自动生成 API。 django 针对 Web 开发中常见的处理逻辑,提供了各种通用视图函数,以提高代码的复用性,减少开发者的工作量。django-rest-framework 同样针对 RESTful API 开发中常见的处理逻辑,提供了各种通用视图函数
多种身份认证和权限认证方式的支持
内置了限流系统;
自动生成API文档。前后端分离开发
除此以外,django-rest-framework 还提供了分页(Pagination)、API 版本控制(Versioning)、缓存(Caching)、**限流(Throtting)**等各种功能类
安装:
pip install djangorestframework
Python (3.7.3)
Django(3.0.1)
我们首先来回顾一下传统的基于模板引擎的 django 开发工作流:
- 绑定 URL 和视图函数。当用户访问某个 URL 时,调用绑定的视图函数进行处理。
- 编写视图函数的逻辑。视图中通常涉及数据库的操作。
- 在视图中渲染 HTML 模板,返回 HTTP 响应。
其实,基于 django-rest-framework 的 RESTful API 的开发,过程是完全类似的:
- 绑定 URL 和视图函数。当用户访问某个 URL 时,调用绑定的视图函数进行处理。
- 编写视图函数的逻辑,根据 HTTP 请求类型,对请求的资源进行相应操作,这个过程通常涉及数据库的操作。
- 使用约定的资源描述格式(例如 XML 或者 JSON)序列化资源并将数据返回给客户端(通过 HTTP 响应)。
1-序列化器Serializer
rest_framework.serializers.Serializer
作用
- 进行数据的校验
- 对数据对象进行转换 ORM->JSON
- 可以操作数据增删改查
1-0 Serializer类
DRF中的Serializer
使用类来定义,须继承自rest_framework.serializers.Serializer
class BookSerializer(serializers.Serializer):
"""图书数据序列化器"""
id = serializers.IntegerField( read_only=True)
title = serializers.CharField( max_length=20)
::: warning
read_only
指定只参与序列化,max_length
限定字符串最大长度。字段里不传参数序列化与反序列化都参与
serializer
不是只能为数据库模型类定义,也可以为非数据库模型类的数据定义。serializer
是独立于数据库之外的存在
- read_only
read_only表示只能读,不能进行修改。例如定义序列化器时,id字段通常指定read_only=True。在序列化时,即对象转为字典、JSON字符串时,字典、JSON字符串包含着id字段。但是反序列化时,即JSON字符串、字典转换为对象时,在参数校验的时候,即使字典有id的键值对,校验不会出错,但是校验后的数据不会有id这个字段,所以id也不会存进数据库。
- write_only
write_only表示只能写,不能读。例如定义序列化器时,password字段(还有短信验证码等)通常指定write_only=True。在序列化时,即对象转为字典、JSON字符串时,字典、JSON字符串不会包含着字段。但是反序列化时,即JSON字符串、字典转换为对象时,在参数校验的时候,校验通过,而且校验后的数据有password这个字段,并且能存进数据库。
Serializer的构造函数的参数
- instance 需要传递一个ORM对象,或者是一个querySet对象。用来将ORM转化Json的
- data 把需要验证的数据传递给data
- many 如果instance是一个querySet对象 需要设置为True默认为False
:::
通用参数说明:
参数名称 | 说明 |
---|---|
read_only | 表明该字段仅用于序列化输出,默认False |
write_only | 表明该字段仅用于反序列化输入,默认False |
required | 表明该字段在反序列化时必须输入,默认True |
default | 反序列化时使用的默认值 |
allow_null | 表明该字段是否允许传入None,默认False |
validators | 该字段使用的验证器 |
error_messages | 包含错误编号与错误信息的字典 |
label | 用于HTML展示API页面时,显示的字段名称 |
help_text | 用于HTML展示API页面时,显示的字段帮助提示信息 |
1-1序列化使用
使用
- 最基本的使用
- 获取单个序列化数据
serializer.data
- 获取多个序列化数据
serializer = BookSerializer(books, many=True) serializer.data
- 获取单个序列化数据
- 关联对象嵌套序列化
heroes = HeroInfoSerializer(many=True) # 根据指定的HeroSerialzier序列化中指定的字段返回
1-2反序列化使用
::: warning
在使用序列化器进行反序列化时,需要对数据进行验证后,才获取成功数据保存模型对象
在获取反序列化数据前,必须调用is_valid() 方法进行验证。 成功True 失败False
验证成功通过序列化器对象的validated_data 属性获取数据
:::
class BookView(View):
# 更新操作
def put(self, request, pk):
data = json.loads(request.body.decode())
try:
# 从模型取数据
book = BookInfo.objects.get(pk=pk)
except Exception:
return JsonResponse({'errors': '未找到该书'})
ser = BookInfoSerializer(book, data=data)
ser.is_valid(raise_exception=True)
同时序列化器提供了其他验证方式
- 验证单个字段
class BookSerializer(serializers.Serializer): def validated_title(self, value): if value == 'python': raise serializers.ValidationError('书名python错误') return value
- 验证多个字段
class BookSerializer(serializers.Serializer): ... def validate(self, attrs): bread = attrs['bread'] bcomment = attrs['bcomment'] if bread < bcomment: raise serializers.ValidationError('阅读量小于评论量') return attrs
保存数据
验证成功后,就可以将数据保存成模型存入数据库。
可以通过实现create()
和update()
两个方法来实现
1-3 模型类序列化器ModelSerializer
如果我们想要使用序列化器对应的是Django的模型类,DRF为我们提供了ModelSerializer模型类序列化器来帮助我们快速创建一个Serializer类
ModelSerializer与常规的Serializer相同,但提供了:
- 基于模型类自动生成一系列字段
- 基于模型类自动为Serializer生成validators,比如unique_together
- 包含默认的create()和update()的实现
class BookInfoSerializer(serializers.ModelSerializer):
"""图书数据序列化器"""
class Meta:
model = BookInfo
fields = '__all__' # 返回所有字段
model 指明参照哪个模型类
fields 指明为模型类的哪些字段生成
可以通过shell
命令查看具体实现
>>> from booktest.serializers import BookSerializer # 导入
>>> serializer = BookSerializer() # 序列化
>>> serializer
BookSerializer():
id = IntegerField(label='ID', read_only=True)
指定字段
- 使用
fields
来明确字段,__all__
表名包含所有字段,也可以写明具体哪些字段
class BookInfoSerializer(serializers.ModelSerializer):
"""图书数据序列化器"""
class Meta:
model = BookInfo # 指定根据哪个模型类来序列化
fields = ('id', 'btitle', 'bpub_date')
- 使用
exclude
可以明确排除掉哪些字段 - 显示指明字段
class HeroInfoSerializer(serializers.ModelSerializer):
hbook = BookInfoSerializer()
class Meta:
model = HeroInfo
fields = ('id', 'hname', 'hgender', 'hcomment', 'hbook')
- 指明只读字段
可以通过read_only_fields指明只读字段,即仅用于序列化输出的字段
添加额外参数
可以使用 extra_kwargs
参数为ModelSerializer
添加或修改原有的选项参数
class BookInfoSerializer(serializers.ModelSerializer):
"""图书数据序列化器"""
class Meta:
model = BookInfo
fields = ('id', 'btitle', 'bpub_date', 'bread', 'bcomment')
extra_kwargs = {
'bread': {'min_value': 0, 'required': True},
'bcomment': {'min_value': 0, 'required': True},
}
2.视图
REST framework
传入DRF封装后视图的request
对象不再是Django
默认的HttpRequest
对象,而是REST framework
提供的扩展了HttpRequest
类的**Request
**类的对象
2.1请求对象Request
REST framework 提供了Parser解析器,在接收到请求后会自动根据Content-Type指明的请求数据类型(如JSON、表单等)将请求数据进行parse解析,解析为类字典对象保存到Request对象中
Request对象的数据是自动根据前端发送数据的格式进行解析之后的结果。
无论前端发送的哪种格式的数据,我们都可以以统一的方式读取数据。
无论前端发过来的是xml还是json,请求方式无论是POST还是PUT,都可以直接用request.data直接取一个字典出来
要继承APIView(或其子类)才能取得DRF的Request和Response
request.query_params 查询参数。 为了代码更加清晰准确,推荐使用request.query_params
,而不是Django中的request.GET
,这样那够让你的代码更加明显的体现出-----任何HTTP方法类型都可能包含查询参数(query parameters),而不仅仅只是'GET'请求。
data
request.data
返回解析之后的请求体(表单、json)数据。类似于Django中标准的request.POST
和 request.FILES
属性,但提供如下特性:
- 包含了解析之后的文件和非文件数据
- 包含了对POST、PUT、PATCH请求方式解析后的数据
- 利用了REST framework的parsers解析器,不仅支持表单类型数据,也支持JSON数据
2.2 响应对象
rest_framework.response.Response
REST framework提供了一个响应类Response
,使用该类构造响应对象时,响应的具体数据内容会被转换(render渲染)成符合前端需求的类型
参数说明:
data
: 为响应准备的序列化处理后的数据;status
: 状态码,默认200;template_name
: 模板名称,如果使用HTMLRenderer
时需指明;headers
: 用于存放响应头信息的字典;content_type
: 响应数据的Content-Type,通常此参数无需传递,REST framework会根据前端所需类型数据来设置该参数。
2.3 状态码
REST framewrok
在rest_framework.status
模块中提供了常用状态码常量。
总是在你的视图中用数字的HTTP状态码会更加容易理解,并且如果你用其他错误代码表示错误,就不太容易注意到了。REST框架为每个状态码(status code)提供更明确的标识符,例如在状态(status)模型中的HTTP_400_BAD_REQUEST。用这些标识符代替纯数字的HTTP状态码是很好的注意
from .models import *
from .serializer import *
from rest_framework.decorators import api_view
from rest_framework.response import Response # Response
from rest_framework import status # status
@api_view(http_method_names=['get','post'])
def index(request):
'''
展示所有图书
:param request:
:return:
'''
if request.method == 'GET':
serializer = BookSerializer(Book.objects.all(), many=True)
return Response(serializer.data)
if request.method == 'POST':
serializer = BookSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
# 自定义状态码
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.data, status=status.HTTP_400_BAD_REQUEST)
如果返回所有图书列表,不用再像以前JsonResponse
中需指定safe=False
了
2.4 类视图APIView
rest_framework.views.APIView
APIView
是REST framework提供的所有视图的基类,继承自Django的View
父类
APIView
与View
的不同之处在于:
- 传入到视图方法中的是REST framework的
Request
对象,而不是Django的HttpRequeset
对象; - 视图方法可以返回REST framework的
Response
对象,视图会为响应数据设置(render)符合前端要求的格式; - 任何
APIException
异常都会被捕获到,并且处理成合适的响应信息; - 在进行dispatch()分发前,会对请求进行身份认证、权限检查、流量控制
支持定义的属性:
- authentication_classes 列表或元祖,身份认证类
- permissoin_classes 列表或元祖,权限检查类
- throttle_classes 列表或元祖,流量控制类
在APIView
中仍以常规的类视图定义方法来实现get() 、post() 或者其他请求方式的方法
from rest_framework.views import APIView
from rest_framework.response import Response
# url(r'^books/$', views.BookListView.as_view()),
class BookListView(APIView):
def get(self, request):
books = BookInfo.objects.all()
serializer = BookInfoSerializer(books, many=True)
return Response(serializer.data)
2.5 GenericAPIView
rest_framework.generics.GenericAPIView
继承自APIVIew
,增加了对于列表视图和详情视图可能用到的通用支持方法。通常使用时,可搭配一个或多个Mixin扩展类
支持定义的属性:
- 列表视图与详情视图通用:
- queryset 列表视图的查询集
- serializer_class 视图使用的序列化器
- 列表视图使用:
- pagination_class 分页控制类
- filter_backends 过滤控制后端
- 详情页视图使用:
- lookup_field 查询单一数据库对象时使用的条件字段,默认为'
pk
' - lookup_url_kwarg 查询单一数据时URL中的参数关键字名称,默认与look_field相同
- lookup_field 查询单一数据库对象时使用的条件字段,默认为'
提供的方法:
- 列表视图与详情视图通用:
- get_queryset(self)
返回视图使用的查询集,是列表视图与详情视图获取数据的基础,默认返回queryset
属性,可以重写,例如:def get_queryset(self): user = self.request.user return user.accounts.all()
- get_serializer_class(self)
返回序列化器类,默认返回serializer_class
,可以重写,例如:def get_serializer_class(self): if self.request.user.is_staff: return FullAccountSerializer return BasicAccountSerializer
get_serializer(self, *args, **kwargs)
返回序列化器对象,被其他视图或扩展类使用,如果我们在视图中想要获取序列化器对象,可以直接调用此方法。
注意,在提供序列化器对象的时候,REST framework会向对象的context属性补充三个数据:request、format、view,这三个数据对象可以在定义序列化器时使用。
- get_queryset(self)
- 详情视图使用:
- get_object(self) 返回详情视图所需的模型类数据对象,默认使用
lookup_field
参数来过滤queryset。 在试图中可以调用该方法获取详情信息的模型类对象。
若详情访问的模型类对象不存在,会返回404。
该方法会默认使用APIView
提供的check_object_permissions方法检查当前对象是否有权限被访问。
- get_object(self) 返回详情视图所需的模型类数据对象,默认使用
from rest_framework.generics import GenericAPIView
class BooksView(GenericAPIView):
queryset = BookInfo.objects.all() #指定查询集
serializer_class = BookInfoSerializer # 指定序列化器
def get(self, request):
'''查询所有图书'''
books = self.get_queryset() 获取查询集
# book = self.get_object() 获取单一数据对象
serializer = self.get_serializer(books, many = True) #获取序列化器
return Response(serializer.data)
def post(self, request):
"""
保存图书
"""
# 1、获取前端数据
data = request.data
# 2、验证数据
ser = self.get_serializer(data=data)
ser.is_valid(raise_exception=True)
# 3、保存数据
ser.save()
# 4、返回结果
return Response(ser.data)
3. 扩展类
3.1 Mixins
mixins 翻译 是 组件、混入的意思。
在DRF中针对获取列表、检索、创建等操作。都有响应的mixins
from rest_framework import mixins
from rest_framework import generics
class BookView(
generics.GenericAPIView,
mixins.ListModelMixin, # 列表视图扩展类
mixins.RetrieveModelMixin, # 详情视图扩展类
mixins.CreateModelMixin, # 创建视图扩展类
mixins.UpdateModelMixin, # 更新视图扩展类
mixins.DestroyModelMixin # 删除视图扩展类
):
'''
图书控制层
列表 /book
新增 /book/
详情 /book/pk/
修改 /book/pk
删除 /book/pk
'''
queryset = Book.objects.all()
serializer_class = BookSerializer
def get(self, request, pk=None):
if pk:
return self.retrieve(request)
else:
return self.list(request)
def post(self, request):
return self.create(request)
def put(self, request, pk=None):
return self.update(request)
def delete(self, request):
return self.delete(request)
ListModelMixin
列表视图扩展类,提供list(request, *args, **kwargs)
方法快速实现列表视图,返回200状态码。
from rest_framework.mixins import ListModelMixin
class BooksView(ListModelMixin, GenericAPIView):
queryset = BookInfo.objects.all()
serializer_class = BookInfoSerializer
def get(self, request):
return self.list(request)
CreateModelMixin
创建视图扩展类,提供create(request, *args, **kwargs)
方法快速实现创建资源的视图,成功返回201状态码。如果序列化器对前端发送的数据验证失败,返回400错误。
from rest_framework.mixins import CreateModelMixin
class BooksView(CreateModelMixin, GenericAPIView):
serializer_class = BookInfoSerializer
def post(self, request):
return self.create(request)
RetrieveModelMixin
详情视图扩展类,提供retrieve(request, *args, **kwargs)
方法,可以快速实现返回一个存在的数据对象。如果存在,返回200, 否则返回404。
class BooksView(RetrieveModelMixin, GenericAPIView):
queryset = BookInfo.objects.all()
serializer_class = BookInfoSerializer
def get(self, request, pk):
return self.retrieve(request)
UpdateModelMixin
更新视图扩展类,提供update(request, *args, **kwargs)
方法,可以快速实现更新一个存在的数据对象。同时也提供partial_update(request, *args, **kwargs)
方法,可以实现局部更新。
成功返回200,序列化器校验数据失败时,返回400错误。
DestroyModelMixin
删除视图扩展类,提供destroy(request, *args, **kwargs)
方法,可以快速实现删除一个存在的数据对象。成功返回204,不存在返回404。
3.2 Generic类视图
同故宫mixin可以非常方便实现一些CRUD操作。
CreateAPIView
实现创建数据的
提供 post 方法
继承自: GenericAPIView、CreateModelMixin
ListAPIView
实现获取列表的
提供 get 方法
继承自:GenericAPIView、ListModelMixin
RetireveAPIView
实现检索数据的
提供 get 方法
继承自: GenericAPIView、RetrieveModelMixin
DestoryAPIView
实现删除数据的
提供 delete 方法
继承自:GenericAPIView、DestoryModelMixin
UpdateAPIView
实现更新数据的
提供 put 和 patch 方法
继承自:GenericAPIView、UpdateModelMixin
RetrieveUpdateAPIView
提供 get、put、patch方法
继承自: GenericAPIView、RetrieveModelMixin、UpdateModelMixin
RetrieveUpdateDestoryAPIView
提供 get、put、patch、delete方法
继承自:GenericAPIView、RetrieveModelMixin、UpdateModelMixin、DestoryModelMixin
from rest_framework import generics
class BookView(
generics.CreateAPIView,
generics.UpdateAPIView,
generics.DestroyAPIView,
generics.RetrieveAPIView
):
queryset = Book.objects.all()
serializer_class = BookSerializer
4.视图集
使用视图集ViewSet
,可以将一系列逻辑相关的动作放到一个类中:
- list() 提供一组数据
- retrieve() 提供单个数据
- create() 创建数据
- update() 保存数据
- destory() 删除数据
ViewSet视图集类不再实现get()、post()等方法,而是实现动作 action 如 list() 、create() 等。
视图集只在使用as_view()方法的时候,才会将action动作与具体请求方式对应上。
class BookInfoViewSet(viewsets.ViewSet):
# 展示所有
def list(self, request):
...
# 展示单个
def retrieve(self, request, pk=None):
...
在设置路由时,我们可以如下操作
urlpatterns = [
url(r'^books/$', BookInfoViewSet.as_view({'get':'list'}),
url(r'^books/(?P<pk>\d+)/$', BookInfoViewSet.as_view({'get': 'retrieve'})
]
action属性
在视图集中,我们可以通过action对象属性来获取当前请求视图集时的action动作是哪个
def get_serializer_class(self):
if self.action == 'create':
return OrderCommitSerializer
else:
return OrderDataSerializera
4.1 ViewSet
继承自APIView,作用也与APIView基本类似,提供了身份认证、权限校验、流量管理等。
在ViewSet中,没有提供任何动作action方法,需要我们自己实现action方法
4.2 GenericViewSet
继承自GenericAPIView
,作用也与GenericAPIVIew类似,提供了get_object、get_queryset等方法便于列表视图与详情信息视图的开发
4.3 ModelViewSet
继承自GenericAPIVIew
,同时包括了ListModelMixin、RetrieveModelMixin、CreateModelMixin、UpdateModelMixin、DestoryModelMixin。所以所有增删改查功能都具备
# 路由层
url(r'^books/$', view_set.BooksModelViewSet.as_view({'get': 'list', 'post': 'create'})),
url(r'^books/(?P<pk>\d+)/$', view_set.BooksModelViewSet.as_view({'get': 'retrieve','put':'update','delete':'destroy'})),
4.4 ReadOnlyModelViewSet
继承自GenericAPIVIew
,同时包括了ListModelMixin、RetrieveModelMixin
from rest_framework import viewsets
class UserViewSet(viewsets.ReadOnlyModelViewSet):
"""
只读API
"""
queryset = User.objects.all()
serializer_class = UserSerializer
from rest_framework import routers
from django.conf.urls import include,url
# 创造和定义路由地址
route = routers.DefaultRouter()
# 注册路由地址
route.register("book", views.BookView)
route.register('tag',views.TagView)
urlpatterns = [
]+route.urls
4.5 定义附加action
在视图集中,除了上述默认的方法动作外,还可以添加自定义动作。
添加自定义动作需要使用rest_framework.decorators.action
装饰器。
以action装饰器装饰的方法名会作为action动作名,与list、retrieve等同。
action装饰器可以接收两个参数:
- methods: 该action支持的请求方式,列表传递
- detail: 表示是action中要处理的是否是视图资源的对象(即是否通过url路径获取主键)
- True 表示使用通过URL获取的主键对应的数据对象
- False 表示不使用URL获取主键
4.6路由Routers
对于视图集ViewSet,我们除了可以自己手动指明请求方式与动作action之间的对应关系外,还可以使用Routers来帮助我们快速实现路由信息。
REST framework提供了两个router
SimpleRouter
DefaultRouter
使用方法
1) 创建router对象,并注册视图集
from rest_framework import routers
router = routers.SimpleRouter()
router.register(r'books', BookInfoViewSet, base_name='book')
##############################
register(prefix, viewset, base_name)
- prefix 该视图集的路由前缀
- viewset 视图集
- base_name 路由名称的前缀
# 上述代码会形成的路由如下
^books/$ name: book-list
^books/{pk}/$ name: book-detail
2)添加路由数据
urlpatterns = [ ...]
urlpatterns += router.urls
# 或者
urlpatterns = [ ..., url(r'^', include(router.urls))]
视图集中包含附加action
导入rest_framework.decorators.action
装饰器可解决上面问题。
...
from rest_framework.decorators import action
class BookInfoViewSet(mixins.ListModelMixin, mixins.RetrieveModelMixin, GenericViewSet):
queryset = BookInfo.objects.all()
serializer_class = BookInfoSerializer
@action(methods=['get'], detail=False) #detail = False不生成正则匹配
def latest(self, request, pk):
...
@action(methods=['put'], detail=True)#detail = True生成正则匹配
def read(self, request, pk):
...
要使用自动生成路由的方法,视图必须继承自视图集。
除了SimpleRouter
,还有DefaultRouter
,区别在于后者能生成首页,而前者不能。
使用视图集只能处理前端通过request发过来的数据是表单或json数据的类型。
5. 认证与授权
DRF 内置认证模块
from rest_framework.authentication import BaseAuthentication
from rest_framework.authentication import SessionAuthentication
from rest_framework.authentication import TokenAuthentication
from rest_framework.authentication import RemoteUserAuthentication
from rest_framework.authentication import BasicAuthentication
在每个视图中通过设置authentication_classess属性来设置
配置分为全局配置|局部配置
BaseAuthentication
基本的授权。 每次都要在Header中把用户名和密码传给服务器。
from .models import *
from .serializer import *
from rest_framework.views import APIView
from rest_framework import viewsets
from rest_framework.authentication import BasicAuthentication
from rest_framework.permissions import IsAuthenticated
class BookView(viewsets .ModelViewSet):
'''
图书控制层
'''
queryset = Book.objects.all()
serializer_class = BookSerializer
# 类属性
# 验证用户是否已经成功登录
authentication_classes = [BasicAuthentication]
# 验证用户的权限来限制访问
permission_classes = [IsAuthenticated]
SessionAuthentication
基于Django的session机制实现的
TokenAuthentication
缺点没有自动过期机制。一旦登录token永久。
Json Web Token
JWT是在成功后,把用户的相关信息以及过期时间进行加密。然后生成一个token来返回给客户端。 客户端拿到可以存储起来。以后每次请求的时候都携带这个token。 服务器在接收到需要登录的API的请求。 对这个token进行解密。 然后获取用户过期时间和用户信息。 如果过期了或者用户的信息不对。都是认证失败
5.1 认证Authentication
全局配置
REST_FRAMEWORK = {
'DEFAULT_AUTHENTICATION_CLASSES': (
'rest_framework.authentication.BasicAuthentication', # 基本表单认证
'rest_framework.authentication.SessionAuthentication', # session认证
)
}
局部配置
from rest_framework.authentication import SessionAuthentication, BasicAuthentication
from rest_framework.views import APIView
class ExampleView(APIView):
authentication_classes = (SessionAuthentication, BasicAuthentication)
...
认证失败会有两种可能的返回值:
- 401 Unauthorized 未认证
- 403 Permission Denied 权限被禁止
5.2 权限Permissions
from rest_framework.permissions import IsAuthenticated
权限控制可以限制用户对于视图的访问和对于具体数据对象的访问
- 在执行视图的dispatch()方法前,会先进行视图访问权限的判断
- 在通过get_object()获取具体对象时,会进行对象访问权限的判断
全局配置
REST_FRAMEWORK = {
'DEFAULT_PERMISSION_CLASSES': (
'rest_framework.permissions.IsAuthenticated', # 授权访问
)
}
默认配置
'DEFAULT_PERMISSION_CLASSES': (
'rest_framework.permissions.AllowAny',
)
局部配置
也可以在具体的视图中通过permission_classes属性来设置
from rest_framework.permissions import IsAuthenticated
from rest_framework.viewsets import ModelViewSet
BooksModelViewSet(ModelViewSet):
permission_classes = (IsAuthenticated,) #登录授权用户
...
提供的权限
- AllowAny 允许所有用户
- IsAuthenticated 仅通过认证的用户
- IsAdminUser 仅管理员用户
- IsAuthenticatedOrReadOnly 认证的用户可以完全操作,否则只能get读取
from rest_framework.authentication import SessionAuthentication # Session 认证
from rest_framework.permissions import IsAuthenticated # 权限
from rest_framework.generics import RetrieveAPIView
class BookListView(RetrieveAPIView):
queryset = BookInfo.objects.all() # 查询
serializer_class = BookInfoSerializer # 序列化
authentication_classes = [SessionAuthentication]
permission_classes = [IsAuthenticated]
6. 其他
6.1 限流Throttling
可以对接口访问的频次进行限制,以减轻服务器压力。
一般用于付费购买次数,投票等场景使用.
可以对接口访问的频次进行限制,以减轻服务器压力,主要用于反爬虫
全局配置
REST_FRAMEWORK = {
'DEFAULT_THROTTLE_CLASSES': (
'rest_framework.throttling.AnonRateThrottle',
'rest_framework.throttling.UserRateThrottle'
),
'DEFAULT_THROTTLE_RATES': {
'anon': '4/day', # 匿名用户每天访问4次
'user': '100/day' # 登录用户访问100次
}
}
DEFAULT_THROTTLE_RATES
可以使用 second
, minute
, hour
或day
来指明周期。
限制视图接口被访问的频率次数 - 限制的条件(IP、id、唯一键)、频率周期时间(s、m、h)、频率的次数(3/s)
局部配置
from rest_framework.throttling import UserRateThrottle
from rest_framework.views import APIView # 视图
class BookListView(APIView):
throttle_classes = (UserRateThrottle,)
...
可选限流类
DRF中,节流的类总共三个
1) AnonRateThrottle
限制所有匿名未认证用户,使用IP区分用户。
使用DEFAULT_THROTTLE_RATES['anon']
来设置频次
2)UserRateThrottle
限制认证用户,使用User id 来区分。
使用DEFAULT_THROTTLE_RATES['user']
来设置频次
如果想要针对不同类型的用户实现不同策略的节流,我们可以通过继承UserRateThrottle类,然后设置scope属性
然后再settings.py
中配置
class AdminRateThrottle(UserRateThrottle):
scope = 'admin'
'DEFAULT_THROTTLE_RATES':{
'normal': '60/day',
'admin': '1000/day'
}
3)ScopedRateThrottle
限制用户对于每个视图的访问频次,使用ip或user id。
这个不管是登录还是未登录。都是根据scope来实现的。
class ConListView(APIView):
throttle_scope = 'uploads'
...
from rest_framework.authentication import SessionAuthentication # Session认证
from rest_framework.permissions import IsAuthenticated # 权限
from rest_framework.generics import RetrieveAPIView # 视图
from rest_framework.throttling import UserRateThrottle # 限速
class BooksView(RetrieveAPIView):
queryset = BookInfo.objects.all()
serializer_class = BookInfoSerializer
authentication_classes = [SessionAuthentication]
permission_classes = [IsAuthenticated]
throttle_classes = (UserRateThrottle,)
...
REST_FRAMEWORK = {
'DEFAULT_THROTTLE_CLASSES': (
'rest_framework.throttling.ScopedRateThrottle',
),
'DEFAULT_THROTTLE_RATES': {
'contacts': '1000/day',
'uploads': '20/day'
}
}
6.2 过滤Filtering
对于列表数据可能需要根据字段进行过滤,我们可以通过添加django-fitlter扩展来增强支持,实现了ListModelMixin
扩展类及子类的视图类才能使用
pip install django-filter
> 2.2.0
在配置文件中增加过滤后端的设置
INSTALLED_APPS = [
...
'django_filters', # 需要注册应用,
]
REST_FRAMEWORK = {
...
'DEFAULT_FILTER_BACKENDS': ('django_filters.rest_framework.DjangoFilterBackend',)
}
在视图中添加filter_fields属性,指定可以过滤的字段
from django_filters.rest_framework import DjangoFilterBackend
class BookView(viewsets.ModelViewSet):
queryset = Book.objects.all()
serializer_class = BookSerializer
filter_backends = [DjangoFilterBackend]
filter_fields = ('id',)
http://127.0.0.1:8888/book/?id=3
6.3 排序OrderingFilter
对于列表数据,REST framework提供了OrderingFilter过滤器来帮助我们快速指明数据按照指定字段进行排序
使用方法:
在类视图中设置filter_backends,使用rest_framework.filters.OrderingFilter过滤器,REST framework会在请求的查询字符串参数中检查是否包含了ordering参数,如果包含了ordering参数,则按照ordering参数指明的排序字段对数据集进行排序。
前端可以传递的ordering参数的可选字段值需要在ordering_fields中指明。
from rest_framework.filters import OrderingFilter
class StudentListView(ListAPIView):
queryset = Student.objects.all()
serializer_class = StudentModelSerializer
filter_backends = [OrderingFilter]
#ordering_fields = ('id', 'age')
ordering_fields = '__all__'
# 127.0.0.1:8000/books/?ordering=-id
# -id 表示针对id字段进行倒序排序
# id 表示针对id字段进行升序排序
# 如果有ordering_fields
# url输入的是该字段,就按该字段排序(ordering_fields必须是可以参与order_by()的字段,否则会报错)否则不排序
# 如果ordering_fields = '__all__':
# 1. 如 url:/ordering = -sdfsfd,则 ordering = None,不排序
# 2. 如 url:/ordering = -price, 则 ordering = -price,按-price排序
# 如果没有指定ordering_fields,
# 1. 不参与序列化,如:sdsadf。则 ordering = None,不排序
# 2. 参与序列化且是表字段,如:price,则 ordering = price, 按price排序,
# 3. 参与序列化不是表字段,如:brand_name, 则 ordering = brand_name,报错(order_by(brand_name)出错
如果需要在过滤以后再次进行排序,则需要两者结合!
from rest_framework.generics import ListAPIView
from students.models import Student
from .serializers import StudentModelSerializer
from django_filters.rest_framework import DjangoFilterBackend
class Student3ListView(ListAPIView):
queryset = Student.objects.all()
serializer_class = StudentModelSerializer
filter_fields = ('age', 'sex')
# 因为局部配置会覆盖全局配置,所以需要重新把过滤组件核心类再次声明,
# 否则过滤功能会失效
filter_backends = [OrderingFilter,DjangoFilterBackend]
ordering_fields = ('id', 'age')
6.4 分页
REST framework提供了分页的支持。
我们可以在配置文件中设置全局的分页方式,如
REST_FRAMEWORK = {
'DEFAULT_PAGINATION_CLASS': 'rest_framework.pagination.PageNumberPagination',
'PAGE_SIZE': 100 # 每页数目
}
也可通过自定义Pagination类,来为视图添加不同分页行为。在视图中通过pagination_class属性来指明
1. PageNumberPagination
from rest_framework.pagination import PageNumberPagination #分页
class LargeResultsSetPagination(PageNumberPagination):
"""
配置分页规则
"""
page_size = 5 # 每页数目
page_size_query_param = 'page_size' # 前端发送的页数关键字名,默认为"page"
page_query_param = 'page' # 前端发送的每页数目关键字名,默认为None
max_page_size = 10000 # 前端最多能设置的每页数量
class BookDetailView(RetrieveAPIView):
queryset = BookInfo.objects.all()
serializer_class = BookInfoSerializer
pagination_class = LargeResultsSetPagination # 应用到视图函数中
注意:如果在视图内关闭分页功能,只需在视图内设置
pagination_class = None
2. LimitOffsetPagination
http://127.0.0.1:8888/book/?limit=20&offset=10
REST_FRAMEWORK = {
'DEFAULT_PAGINATION_CLASS': 'rest_framework.pagination.LimitOffsetPagination'
}
可以在子类中定义的属性
default_limit 默认限制,默认值与PAGE_SIZE
设置一直
limit_query_param limit参数名,默认'limit'
offset_query_param offset参数名,默认'offset'
max_limit 最大limit限制,默认None
from rest_framework.pagination import LimitOffsetPagination
class BookListView(ListAPIView):
queryset = BookInfo.objects.all().order_by('id')
serializer_class = BookInfoSerializer
pagination_class = LimitOffsetPagination
# 127.0.0.1:8000/books/?offset=3&limit=2
7. 异常处理
REST framework提供了异常处理,我们可以自定义异常处理函数。
from rest_framework.views import exception_handler
def custom_exception_handler(exc, context):
# 先调用REST framework默认的异常处理方法获得标准错误响应对象
response = exception_handler(exc, context)
# 在此处补充自定义的异常处理
if response is not None:
response.data['status_code'] = response.status_code
return response
全局配置
REST_FRAMEWORK = {
'EXCEPTION_HANDLER': 'my_project.my_app.utils.custom_exception_handler'#定义处理异常的路径,以项目实际为准
}
如果未声明,会采用默认的方式,如下
REST_FRAMEWORK = {
'EXCEPTION_HANDLER': 'rest_framework.views.exception_handler'
}
REST framework定义的异常
APIException 所有异常的父类
ParseError 解析错误
AuthenticationFailed 认证失败
NotAuthenticated 尚未认证
PermissionDenied 权限决绝
NotFound 未找到
MethodNotAllowed 请求方式不支持
NotAcceptable 要获取的数据格式不支持
Throttled 超过限流次数
ValidationError 校验失败