rest_framework_django 学习笔记二（视图路由）
rest_framework_django 学习笔记二（视图路由）
rest_framwork_django学习笔记一(序列化器)
一、rest framework 中Request 与 Response
1、Request
REST framework 传入视图的request对象不再是Django默认的HttpRequest对象，二是REST Famework 提供的扩展了 Http Request 类的Request 类的对象。
REST framework 提供了 Parser 解析器，在接受到请求后悔自藕丁工具Content-Type 指明的请求数据类型（如JSON、表单等）将请求数据就行parse 解析，解析为类字典对象保存到Request对象中。
Request对象的数据时自动工具前端发送的哪种格式的数据，我们都可以以统一的方式读取数据。
常用属性
1).data
request.data 返回解析之后的请求数据 类似于django中标准的 request.POST 和request.FILES属性，但提供如下特性：
- 包含了解析之后的文件和非文件数据；
- 包含了对POST，PUT，PATCH请求方式解析后的数据；
- 利用REST ftamework 的parsers 解析器，不仅支持表单类型数据，也支持JSON数据；
2）.query_params
request.query_params 与 django标准的 request.GET 相同，只是更换了更准确的名称而已。
2、Response
rest_framework.response.Response
REST framework 提供了一个响应类 Response，使用该类构造响应对象时，响应的具体数据内容会被转换（render渲染）成符合前端需求的类型。
REST framework 提供了 Renderer 渲染器，用来工具请求头中的 Accept （接收数据类型声明）来自自动转换响应数据到对应格式。如果前端请求中为进行 Accept 声明，则会采用默认方式处理响应数据，我们可以通过配置来修改默认响应格式。
# settings.py
# ================================================= #
# ***************** REST_FRAMEWORK **************** #
# ================================================= #
REST_FRAMEWORK = {
"DATETIME_FORMAT": "%Y-%m-%d %H:%M:%S", # 日期时间格式配置
"DATE_FORMAT": "%Y-%m-%d",
'DEFAULT_PERMISSION_CLASSES': [
'rest_framework.renderers.JONSRenderer',#json 渲染器
'rest_framework.renderers,BrowsableAPIRenderer',# 浏览API渲染器
],
}
构造方式
Response(data,status=None,template_name=None,headers=None,content_type=None)
data 数据不要是 render 处理之后的数据，只是传递 python 的内建类型数据即可，REST framework 会使用 renderer 渲染器处理 data .
data不能是复杂结构的数据，如 Django的模型对象，对于这样的数据我们可以使用 Serializer 序列化器序列化处理后（转为了python字典类型）再传递给 data 参数。
参数说明：
- data：为响应准备的序列化处理后的数据；
- status：状态吗，默认200；
- template_name：末班名称，如果使用HTMLRenderer 时需要指明；
- headers：用于存放响应头信息的字典；
- content_type:响应数据的Content_type，通常此参数无需传递，REST framework 会工具前端所需类型数据来设置该参数。
常用属性
1).data
传给 response 对象的序列化后，但尚未 render 处理的数据
2）.status_code
状态码的数字
3）.content
结果 render 处理后的响应数据
状态码
为了方便设置状态码 REST framework 在 rest_framework.status 模块中提供了常用状态码常量。
rest_framework.status
1)信息告知 - 1xx
HTTP_100_CONTINUE = 100
HTTP_101_SWITCHING_PROTOCOLS = 101
HTTP_102_PROCESSING = 102
HTTP_103_EARLY_HINTS = 103
2) 成功 - 2xx
HTTP_200_OK = 200
HTTP_201_CREATED = 201
HTTP_202_ACCEPTED = 202
HTTP_203_NON_AUTHORITATIVE_INFORMATION = 203
HTTP_204_NO_CONTENT = 204
HTTP_205_RESET_CONTENT = 205
HTTP_206_PARTIAL_CONTENT = 206
HTTP_207_MULTI_STATUS = 207
HTTP_208_ALREADY_REPORTED = 208
HTTP_226_IM_USED = 226
3)重定向 - 3xx
HTTP_300_MULTIPLE_CHOICES = 300
HTTP_301_MOVED_PERMANENTLY = 301
HTTP_302_FOUND = 302
HTTP_303_SEE_OTHER = 303
HTTP_304_NOT_MODIFIED = 304
HTTP_305_USE_PROXY = 305
HTTP_306_RESERVED = 306
HTTP_307_TEMPORARY_REDIRECT = 307
HTTP_308_PERMANENT_REDIRECT = 308
4)客户端错误 - 4xx
HTTP_400_BAD_REQUEST = 400
HTTP_401_UNAUTHORIZED = 401
HTTP_402_PAYMENT_REQUIRED = 402
HTTP_403_FORBIDDEN = 403
HTTP_404_NOT_FOUND = 404
HTTP_405_METHOD_NOT_ALLOWED = 405
HTTP_406_NOT_ACCEPTABLE = 406
HTTP_407_PROXY_AUTHENTICATION_REQUIRED = 407
HTTP_408_REQUEST_TIMEOUT = 408
HTTP_409_CONFLICT = 409
HTTP_410_GONE = 410
HTTP_411_LENGTH_REQUIRED = 411
HTTP_412_PRECONDITION_FAILED = 412
HTTP_413_REQUEST_ENTITY_TOO_LARGE = 413
HTTP_414_REQUEST_URI_TOO_LONG = 414
HTTP_415_UNSUPPORTED_MEDIA_TYPE = 415
HTTP_416_REQUESTED_RANGE_NOT_SATISFIABLE = 416
HTTP_417_EXPECTATION_FAILED = 417
HTTP_418_IM_A_TEAPOT = 418
HTTP_421_MISDIRECTED_REQUEST = 421
HTTP_422_UNPROCESSABLE_ENTITY = 422
HTTP_423_LOCKED = 423
HTTP_424_FAILED_DEPENDENCY = 424
HTTP_425_TOO_EARLY = 425
HTTP_426_UPGRADE_REQUIRED = 426
HTTP_428_PRECONDITION_REQUIRED = 428
HTTP_429_TOO_MANY_REQUESTS = 429
HTTP_431_REQUEST_HEADER_FIELDS_TOO_LARGE = 431
HTTP_451_UNAVAILABLE_FOR_LEGAL_REASONS = 451
5)服务端错误 - 5xx
HTTP_500_INTERNAL_SERVER_ERROR = 500
HTTP_501_NOT_IMPLEMENTED = 501
HTTP_502_BAD_GATEWAY = 502
HTTP_503_SERVICE_UNAVAILABLE = 503
HTTP_504_GATEWAY_TIMEOUT = 504
HTTP_505_HTTP_VERSION_NOT_SUPPORTED = 505
HTTP_506_VARIANT_ALSO_NEGOTIATES = 506
HTTP_507_INSUFFICIENT_STORAGE = 507
HTTP_508_LOOP_DETECTED = 508
HTTP_509_BANDWIDTH_LIMIT_EXCEEDED = 509
HTTP_510_NOT_EXTENDED = 510
HTTP_511_NETWORK_AUTHENTICATION_REQUIRED = 511
自定义返回
# -*- coding: utf-8 -*-
from rest_framework.response import Response
class SuccessResponse(Response):
"""
标准响应成功的返回, SuccessResponse(data)或者SuccessResponse(data=data)
(1)默认code返回2000, 不支持指定其他返回码
"""
def __init__(self, data=None, msg='success', status=None, template_name=None, headers=None, exception=False,
content_type=None,page=1,limit=1,total=1):
std_data = {
"code": 2000,
"data": {
"page": page,
"limit": limit,
"total": total,
"data": data
},
"msg": msg
}
super().__init__(std_data, status, template_name, headers, exception, content_type)
class DetailResponse(Response):
"""
不包含分页信息的接口返回,主要用于单条数据查询
(1)默认code返回2000, 不支持指定其他返回码
"""
def __init__(self, data=None,
msg='success',
status=None,
template_name=None,
headers=None,
exception=False,
content_type=None,):
std_data = {
"code": 2000,
"data": data,
"msg": msg
}
super().__init__(std_data, status, template_name, headers, exception, content_type)
class ErrorResponse(Response):
"""
标准响应错误的返回,ErrorResponse(msg='xxx')
(1)默认错误码返回400, 也可以指定其他返回码:ErrorResponse(code=xxx)
"""
def __init__(self, data=None, msg='error', code=400, status=None, template_name=None, headers=None,
exception=False, content_type=None):
std_data = {
"code": code,
"data": data,
"msg": msg
}
super().__init__(std_data, status, template_name, headers, exception, content_type)
二、视图
1、两个基类
1.1 APIView
rest_framework.views.APIView
APIView 是 REST framework 提供的所有视图的基类，继承自django的 view 父类。
APIView 与 view 的不同之处在于：
- 传入到视图方法中的是REST framework 的 request 对象，而不是 django 的 HttpRequest 对象；
- 视图方法可以返回 REST framework 的 Response 对象，视图会响应数据设置（render）符合前端要求的格式；
- 任何 APIException 异常都会被捕获到，并且处理成合适的响应学习；
- 在进行 dispatch() 分发前，会对请求进行身份认证、权限检查、流量控制；
支持定义的属性：
- authentication_classes 列表或原则，身份认证类；
- permissoin_classes 列表或元祖，权限检查类；
- throttle_classes 列表或元祖，流量控制类；
在 APIView 中仍以常规的类视图定义方法来实现 get()\post() 或者其他请求方式的方法。
''' 序列化器 '''
from rest_framework import serializers
from .models import Book, Publish, Author,AuthorDetail
class PublishSerializer(serializers.ModelSerializer):
class Meta:
model = Publish
fields = '__all__'
''' urls.py '''
urlpatterns = [
path('publish/',PublishListAPIView.as_view()),# 列表视图
path('publish//' ,PublishDetaAPIView.as_view()),# 详情视图
]
1）查询列表
from rest_framework.views import APIView
from rest_framework.response import Response
from .models import *
from .serializers import *
class PublishListAPIView(APIView):
''' 列表视图 '''
def get(self,request):
''' 查询所有 '''
publish_list = Publish.objects.filter()
serializer = PublishSerializer(instance=publish_list, many=True)
return Response(serializer.data)
2）增
from rest_framework.views import APIView
from rest_framework.response import Response
from .models import *
from .serializers import *
class PublishListAPIView(APIView):
''' 列表视图 '''
def get(self,request):
''' 查询所有 '''
publish_list = Publish.objects.filter()
serializer = PublishSerializer(instance=publish_list, many=True)
response = Response(data=serializer.data)
return response
# return Response(serializer.data)
def post(self,request):
''' 新增 '''
# 1、获取前端传入的数据
data = request.data
# 2、创建序列化器进行反序列化
serializer = PublishSerializer(data=data)
# 3、调用序列化器 is_valid 方法进行校验
serializer.is_valid(raise_exception=True)
# 4、调用序列化器的save() 方法进行执行 create 方法
serializer.save()
# 5、响应
return Response(serializer.data)
3）删
from rest_framework.views import APIView
from rest_framework.response import Response
from .models import *
from .serializers import *
from rest_framework import status
class PublishDetaAPIView(APIView):
''' 详情列表 '''
def delete(self,request,id):
try:
publish = Publish.objects.filter(pk=id).first()
except Publish.DoesNotExist:
return Response(status=status.HTTP_404_NOT_FOUND)
publish.delete()
return Response(status=status.HTTP_200_OK)
4）改
from rest_framework.views import APIView
from rest_framework.response import Response
from .models import *
from .serializers import *
from rest_framework import status
class PublishDetaAPIView(APIView):
''' 详情列表 '''
def put(self,request,id):
''' 修改 '''
# 1、查询修改内容
publish_obj = Publish.objects.filter(pk=id).first()
if not publish_obj:
return Response(status=status.HTTP_404_NOT_FOUND)
# 2、获取前端出入的请求体数据
data = request.data
# 3、创建序列化器进行反序列化
serializer = PublishSerializer(instance=publish_obj,data=data)
# 4、校验
serializer.is_valid(raise_exception=True)
serializer.save()
# 5、保存
return Response(serializer.data)
增删查改代码全
''' urls.py'''
urlpatterns = [
path('publish/',PublishListAPIView.as_view()),# 列表视图 增加、查询数据列表
path('publish//' ,PublishDetaAPIView.as_view()),# 详情视图 删除、单一查询、修改
]
from rest_framework import serializers
from .models import Book, Publish, Author,AuthorDetail
class PublishSerializer(serializers.ModelSerializer):
''' 序列化器 '''
class Meta:
model = Publish
fields = '__all__'
from django.db import models
''' models.py '''
class Publish(models.Model):
name = models.CharField(max_length=32)
city = models.CharField(max_length=64)
email = models.EmailField()
class Meta:
verbose_name = '出版社表'
# coding=utf-8
'''
@date：2023/11/20 13:37
@mail：[email protected]
@Content:
APIView 序列化器
'''
from rest_framework.views import APIView
from rest_framework.response import Response
from .models import *
from .serializers import *
from rest_framework import status
class PublishListAPIView(APIView):
''' 列表视图 '''
def get(self,request):
''' 查询所有 '''
publish_list = Publish.objects.filter()
serializer = PublishSerializer(instance=publish_list, many=True)
response = Response(data=serializer.data)
return response
# return Response(serializer.data)
def post(self,request):
''' 新增 '''
# 1、获取前端传入的数据
data = request.data
# 2、创建序列化器进行反序列化
serializer = PublishSerializer(data=data)
# 3、调用序列化器 is_valid 方法进行校验
serializer.is_valid(raise_exception=True)
# 4、调用序列化器的save() 方法进行执行 create 方法
serializer.save()
# 5、响应
return Response(serializer.data)
class PublishDetaAPIView(APIView):
''' 详情列表 '''
def get(self,request,id):
''' 查询 pk '''
# 查询pk
publish_obj = Publish.objects.filter(pk = id).first();
if not publish_obj:
return Response(status=status.HTTP_404_NOT_FOUND)
# 将查询内容序列化
serializer = PublishSerializer(instance = publish_obj)
# 响应
response = Response(data=serializer.data)
return response
def put(self,request,id):
''' 修改 '''
# 1、查询修改内容
publish_obj = Publish.objects.filter(pk=id).first()
if not publish_obj:
return Response(status=status.HTTP_404_NOT_FOUND)
# 2、获取前端出入的请求体数据
data = request.data
# 3、创建序列化器进行反序列化
serializer = PublishSerializer(instance=publish_obj,data=data)
# 4、校验
serializer.is_valid(raise_exception=True)
serializer.save()
# 5、保存
return Response(serializer.data)
def delete(self,request,id):
''' 删除 '''
try:
publish = Publish.objects.filter(pk=id).first()
except Publish.DoesNotExist:
return Response(status=status.HTTP_404_NOT_FOUND)
publish.delete()
return Response(status=status.HTTP_200_OK)
1.2 GenericAPIView
rest_framework.generics.GenericAPIView
继承自 APIVIew，主要增加了操作序列化器和数据查询的方法，作用是为了Mixin扩展类的执行提供方法支持，通常在使用时，可搭配一个或多个 Mixin扩展类；
提供的相关序列化器使用的属性与方法
属性：
- serializer_class 指明视图使用的序列化器
方法：
- get_serializer_class(self)
返回序列化器类，默认范湖 serializer_class，可以 重写。例如：
def get_serializer_class(self):
if self.request.user.is_staff:
return FullAccounSerializer
return BasicAccountSerializer
- get_serializer(self,args,*Kwargs)
返回序列化器对象，主要用来提供给Mixin扩展类使用，如果我们在视图中想要获取序列化器对象也可以直接调用此方法。
注意，该方法在提供序列化器对象的时候，会向序列化器对象的 context属性补充三个数据：request、format、view，这三个数据对象可以在定义序列化器时使用。
- request 当前视图的请求对象
- view 当前请求的类视图对象
- format 当前请求期望返回的数据格式
提供的关于数据库查询的属性与方法
属性：
- queryser 指明使用的数据查询集
方法：
- get_queryset(self)
返回视图使用的查询集，主要用来提供给Mixin 扩展使用，是列表视图与相求视图获取数据的基础，默认返回 queryset 属性，可以重写，例如：
def get_queryset(self):
user = self.request.user
return user.accounts.all()
- get_object(self)
返回详情视图所需的模型类数据对象，主要用来提供给Mixin扩展类使用。
在视图中可以调用该方法获取详情学习的模型类对象。
若详情访问的模型类对象不存在，会返回404.
该方法默认使用 APIView 提供的check_object_permissions 方法检查当前对象是否有权限被访问。
from rest_framework.generics import GenericAPIView
from rest_framework.response import Response
from .models import *
from .serializers import *
class PublishListGenericAPIView(GenericAPIView):
# 指定序列化器的 类
serializer_class = PublishSerializer
# 指定查询集 ’数据来源‘
queryset = Publish.objects.all()
def get(self,reqest):
publish = self.get_queryset() # 获取所有数据
serializer = self.get_serializer(publish,many=True)# 构造序列化器对象
return Response(data=serializer.data)
class PublishDetaGenericAPIView(GenericAPIView):
''' 详情视图 '''
# 指定序列化器的 类
serializer_class = PublishSerializer
# 指定查询集 ’数据来源‘
queryset = Publish.objects.all()
def get(self,request,pk):
''' 查询 单一'''
publish = self.get_object()# 查询单一
serializer = self.get_serializer(publish)
return Response(data=serializer.data)
urls.py
from .generic_apiview_views import *
from django.urls import path
urlpatterns = [
# GenericAPIView
path('publish/',PublishListGenericAPIView.as_view()),# 列表视图
# GenericAPIView
path('publish//' ,PublishDetaGenericAPIView.as_view()),# 详情视图
]
其他扩展
- pagination_class 指明分页控制类
- filter_backends 指明过滤控制后端
- ordering_fields 指明过滤中的排序后端
- authentication_classes 指明认证后端
- permission_classes 指明权限后端
1）查询、修改、单个查询
from .generic_apiview_views import *
from django.urls import path
urlpatterns = [
# GenericAPIView
path('publish/',PublishListGenericAPIView.as_view()),# 列表视图
# GenericAPIView
path('publish//' ,PublishDetaGenericAPIView.as_view()),# 详情视图
]
from rest_framework.generics import GenericAPIView
from rest_framework.response import Response
from .models import *
from .serializers import *
class PublishListGenericAPIView(GenericAPIView):
# 指定序列化器的 类
serializer_class = PublishSerializer
# 指定查询集 ’数据来源‘
queryset = Publish.objects.all()
def get(self,reqest):
'''
'''
publish = self.get_queryset() # 获取所有数据
serializer = self.get_serializer(publish,many=True)# 构造序列化器对象
return Response(data=serializer.data)
class PublishDetaGenericAPIView(GenericAPIView):
''' 详情视图 '''
# 指定序列化器的 类
serializer_class = PublishSerializer
# 指定查询集 ’数据来源‘
queryset = Publish.objects.all()
def get(self,request,pk):
''' 查询 单一'''
publish = self.get_object()# 查询单一
serializer = self.get_serializer(publish)
return Response(data=serializer.data)
def put(self,request,pk):
publish = self.get_object()
serializer = self.get_serializer(publish,request.data)
serializer.is_valid(raise_exception = True)
serializer.save()
return Response(serializer.data)
2） 整合 Mixin 实现简单增删查改操作
from rest_framework.generics import GenericAPIView
from rest_framework.response import Response
from rest_framework.mixins import ListModelMixin,CreateModelMixin,DestroyModelMixin,RetrieveModelMixin,UpdateModelMixin
from .serializers import *
class PublishListGenericAPIView(ListModelMixin,CreateModelMixin,GenericAPIView):
# 指定序列化器的 类
serializer_class = PublishSerializer
# 指定查询集 ’数据来源‘
queryset = Publish.objects.all()
def get(self,request):
''' 查询 '''
return self.list(request=request)
def post(self,request):
''' 新增 '''
return self.create(request)
class PublishDetaGenericAPIView(RetrieveModelMixin,DestroyModelMixin,UpdateModelMixin,GenericAPIView):
''' 详情视图 '''
# 指定序列化器的 类
serializer_class = PublishSerializer
# 指定查询集 ’数据来源‘
queryset = Publish.objects.all()
def get(self,request,pk):
''' 查询 单一'''
return self.retrieve(request,pk)
def put(self,request,pk):
''' 修改 '''
return self.update(request,pk)
def delete(self,request,pk):
''' 删除 '''
return self.destroy(request,pk)
3) 简化后的 GenericApiView增删查改
from .generic_apiview_views import *
from django.urls import path
urlpatterns = [
# GenericAPIView
path('publish/',PublishListGenericAPIView.as_view()),# 列表视图
# GenericAPIView
path('publish//' ,PublishDetaGenericAPIView.as_view()),# 详情视图
]
rest_framework.generics.ListAPIView # 列表查询
rest_framework.generics.CreateAPIView # 新增
rest_framework.generics.UpdateAPIView # 修改
rest_framework.generics.DestroyAPIView #删除
rest_framework.generics.RetrieveAPIView # 查询一条数据
rest_framework.generics.ListCreateAPIView # 列表查询 + 新增
rest_framework.generics.RetrieveUpdateDestroyAPIView # 单个查询，修改，删除
from rest_framework.generics import GenericAPIView,\
ListAPIView,\
CreateAPIView,\
UpdateAPIView,\
DestroyAPIView,\
RetrieveAPIView,\
ListCreateAPIView,\
RetrieveUpdateDestroyAPIView
from .serializers import *
class PublishListGenericAPIView(ListCreateAPIView,GenericAPIView):
# 指定序列化器的 类
serializer_class = PublishSerializer
# 指定查询集 ’数据来源‘
queryset = Publish.objects.all()
class PublishDetaGenericAPIView(RetrieveUpdateDestroyAPIView,GenericAPIView):
''' 详情视图 '''
# 指定序列化器的 类
serializer_class = PublishSerializer
# 指定查询集 ’数据来源‘
queryset = Publish.objects.all()
2、视图集ViewSet
2.1 ViewSet
使用视图集 ViewSet，可以将一系列逻辑相关的动作放到一个类中：
- list() 提供一组数据
- retrieve() 提供单个数据
- create() 创建数据
- update() 保存数据
- destory() 删除数据
ViewSet 视图集类不再实现 get()、post() 等方法，而是实现动作 action 如list()、create() 等。
视图集只在使用 as_view() 方法的时候，才会到 action 动作与具体请求方式对应上，如：
from rest_framework.viewsets import ViewSet
from rest_framework.response import Response
from .serializers import PublishSerializer
from .models import *
class PublishViewset(ViewSet):
def list(self,request):
objects_filter = Publish.objects.filter()
serializer = PublishSerializer(instance=objects_filter,many=True)
return Response(data=serializer.data)
def add(self,request):
''' 方法未实现 '''
pass
def delete(self,request,pk):
''' 方法未实现 '''
pass
def get_by(self,request,pk):
objects_filter = Publish.objects.filter(pk=pk).first()
serializer = PublishSerializer(instance=objects_filter)
return Response(data=serializer.data)
def update(self,request,pk):
''' 方法未实现 '''
pass
在设置路由时，我们可以如下操作：
from .view_set_views import *
from django.urls import path
urlpatterns = [
# GenericAPIView
path('publish/',PublishViewset.as_view({'get':'list','post':'add'})),# 列表视图
# GenericAPIView
path('publish//' ,PublishViewset.as_view({'get':'get_by','delete':'delete','put':'update'})),# 详情视图
]
继承自 APIView 与ViewSetMixin ，作用也与APIView 基本类似，提供了身份认证、权限校验、流量管理等。
ViewSet 主要通过继承ViewSetMixin 来实现在调用 as_view() 时传入字典（如{‘get’:‘list’}）的映射处理工作。
在ViewSet中，没有提供如何动作 action 方法，需要我们自己实现 action 方法
2.2 GenericViewset
使用ViewSet 通常并不方便，因为list、retrieve、create、update、destory 等方法都需要自己编写、而这些方法与前面讲的 Mixin 扩展类提供的方法同名，所以我们可以通过继承 Mixin 扩展类来服用这些方法而无需自己编写，但是Mixin扩展类依赖于 GenericAPIView ，所以还需要继承 GenericAPIView.
GenericViewSet 就帮助我们完成了这样的继承工作，继承自 GenericAPIView 与 ViewSetMixin,在实现了调用as_view() 时传入字典（如{‘get’:‘list’}）的映射处理工作同时，还提供了 GenericAPIView 提供的基础方法，可以直接搭配Minxin 扩展类使用。
举例：
urls.py
from .view_set_views import *
from django.urls import path
urlpatterns = [
# GenericViewSet 整合 mixins
path('publish/',PublishViewset.as_view({'get':'list','post':'create'})),# 列表视图
# GenericViewSet 整合 mixins
path('publish//' ,PublishViewset.as_view({'get':'retrieve','delete':'destroy','put':'update'})),# 详情视图
]
''' 原始 GenericViewSet 配合 mixin '''
from rest_framework.viewsets import ViewSet,GenericViewSet,ReadOnlyModelViewSet
from rest_framework.mixins import ListModelMixin,RetrieveModelMixin,CreateModelMixin,UpdateModelMixin,DestroyModelMixin
from .serializers import PublishSerializer
from .models import *
class PublishViewset(GenericViewSet,ListModelMixin,RetrieveModelMixin,CreateModelMixin,DestroyModelMixin,UpdateModelMixin):
''' 视图集 '''
queryset = Publish.objects.all()
serializer_class = PublishSerializer
2.3ReadOnlyModelViewSet
rest_framework.viewsets.ReadOnlyModelViewSet
from rest_framework.viewsets import GenericViewSet,ReadOnlyModelViewSet,ModelViewSet
from .serializers import PublishSerializer
from .models import *
class PublishViewset(ReadOnlyModelViewSet,ModelViewSet):
''' 视图集 '''
queryset = Publish.objects.all()
serializer_class = PublishSerializer
2.4ModelViewSet
rest_framework.viewsets.ModelViewSet
3、视图集中定义附加 action 动作
3.1 增加自定义方法
from .view_set_views import *
from django.urls import path
from .book_views import BookModelViewSet
urlpatterns = [
path('book/', BookModelViewSet.as_view({'get': 'list', 'post': 'create'})), # 列表视图
path('book//' , BookModelViewSet.as_view({'get': 'retrieve', 'delete': 'destroy', 'put': 'update'})),
# 详情视图
path('book/get_book', BookModelViewSet.as_view({'get': 'get_book'})), # 通过获取大于 多少钱的书
path('book//update_book_price' , BookModelViewSet.as_view({'put': 'update_book_price'})), # 修改书的价格
]
from django.db.models import Q
from rest_framework.viewsets import ModelViewSet
from .serializers import BookSerializer
from .models import Book
from rest_framework.response import Response
class BookModelViewSet(ModelViewSet):
queryset = Book.objects.all()
serializer_class = BookSerializer
def get_book(self,request):
''' 查询 price 大于data['price']的书 '''
data = request.data
book_qy = Q(price__gt=data['price'])
book_list = Book.objects.filter(book_qy) # 工具id获取最后一本书
serializer = self.get_serializer(book_list,many=True)
return Response(serializer.data)
def update_book_price(self,request,pk):
''' 修改某一本书的价格 '''
book_object = self.get_object()
book_object.price = request.data['price']
book_object.save()
serializer = self.get_serializer(book_object)
return Response(serializer.data)
4、总结
4.1APIView
在APIView中的request直接叫 request；
django中的响应对象叫HttpResponse，而APIView中的叫Response；
APIView中新增了异常捕获；
在APIView中可以用序列化器；
''' urls.py '''
urlpatterns = [
path('publish/',PublishListAPIView.as_view()),# 列表视图
path('publish//' ,PublishDetaAPIView.as_view()),# 详情视图
]
from rest_framework.views import APIView
from rest_framework.response import Response
from .models import *
from .serializers import *
from rest_framework import status
class PublishListAPIView(APIView):
''' 列表视图 '''
def get(self,request):
''' 查询所有 '''
publish_list = Publish.objects.filter()
serializer = PublishSerializer(instance=publish_list, many=True)
response = Response(data=serializer.data)
return response
# return Response(serializer.data)
def post(self,request):
''' 新增 '''
# 1、获取前端传入的数据
data = request.data
# 2、创建序列化器进行反序列化
serializer = PublishSerializer(data=data)
# 3、调用序列化器 is_valid 方法进行校验
serializer.is_valid(raise_exception=True)
# 4、调用序列化器的save() 方法进行执行 create 方法
serializer.save()
# 5、响应
return Response(serializer.data)
class PublishDetaAPIView(APIView):
''' 详情列表 '''
def get(self,request,id):
''' 查询 pk '''
# 查询pk
publish_obj = Publish.objects.filter(pk = id).first();
if not publish_obj:
return Response(status=status.HTTP_404_NOT_FOUND)
# 将查询内容序列化
serializer = PublishSerializer(instance = publish_obj)
# 响应
response = Response(data=serializer.data)
return response
def put(self,request,id):
''' 修改 '''
# 1、查询修改内容
publish_obj = Publish.objects.filter(pk=id).first()
if not publish_obj:
return Response(status=status.HTTP_404_NOT_FOUND)
# 2、获取前端出入的请求体数据
data = request.data
# 3、创建序列化器进行反序列化
serializer = PublishSerializer(instance=publish_obj,data=data)
# 4、校验
serializer.is_valid(raise_exception=True)
serializer.save()
# 5、保存
return Response(serializer.data)
def delete(self,request,id):
''' 删除 '''
try:
publish = Publish.objects.filter(pk=id).first()
except Publish.DoesNotExist:
return Response(status=status.HTTP_404_NOT_FOUND)
publish.delete()
return Response(status=status.HTTP_200_OK)
4.2GenericAPIView
GenericAPIView 继承的就是 APIView；
GenericAPIView 增加了分页和过滤功能；
''' urls.py '''
urlpatterns = [
path('publish/',PublishListAPIView.as_view()),# 列表视图
path('publish//' ,PublishDetaAPIView.as_view()),# 详情视图
]
from rest_framework.generics import GenericAPIView
from rest_framework.response import Response
from .models import *
from .serializers import *
class PublishListGenericAPIView(GenericAPIView):
# 指定序列化器的 类
serializer_class = PublishSerializer
# 指定查询集 ’数据来源‘
queryset = Publish.objects.all()
def get(self,reqest):
publish = self.get_queryset() # 获取所有数据
serializer = self.get_serializer(publish,many=True)# 构造序列化器对象
return Response(data=serializer.data)
class PublishDetaGenericAPIView(GenericAPIView):
''' 详情视图 '''
# 指定序列化器的 类
serializer_class = PublishSerializer
# 指定查询集 ’数据来源‘
queryset = Publish.objects.all()
def get(self,request,pk):
''' 查询 单一'''
publish = self.get_object()# 查询单一
serializer = self.get_serializer(publish)
return Response(data=serializer.data)
1) GenericAPIView + Minxin
''' urls.py '''
urlpatterns = [
path('publish/',PublishListAPIView.as_view()),# 列表视图
path('publish//' ,PublishDetaAPIView.as_view()),# 详情视图
]
from rest_framework.generics import GenericAPIView
from rest_framework.response import Response
from rest_framework.mixins import ListModelMixin,CreateModelMixin,DestroyModelMixin,RetrieveModelMixin,UpdateModelMixin
from .serializers import *
class PublishListGenericAPIView(ListModelMixin,CreateModelMixin,GenericAPIView):
# 指定序列化器的 类
serializer_class = PublishSerializer
# 指定查询集 ’数据来源‘
queryset = Publish.objects.all()
def get(self,request):
''' 查询 '''
return self.list(request=request)
def post(self,request):
''' 新增 '''
return self.create(request)
class PublishDetaGenericAPIView(RetrieveModelMixin,DestroyModelMixin,UpdateModelMixin,GenericAPIView):
''' 详情视图 '''
# 指定序列化器的 类
serializer_class = PublishSerializer
# 指定查询集 ’数据来源‘
queryset = Publish.objects.all()
def get(self,request,pk):
''' 查询 单一'''
return self.retrieve(request,pk)
def put(self,request,pk):
''' 修改 '''
return self.update(request,pk)
def delete(self,request,pk):
''' 删除 '''
return self.destroy(request,pk)
4.3 ViewSet
from .views import *
from django.urls import path
urlpatterns = [
# 可以使用 路由器
# ViewSet
path('publish/',PublishViewset.as_view({'get':'list','post':'add'})),# 列表视图
# ViewSet
path('publish//' ,PublishViewset.as_view({'get':'get_by','delete':'delete','put':'update'})),# 详情视图
]
from rest_framework.viewsets import ViewSet
from rest_framework.response import Response
from .serializers import PublishSerializer
from .models import *
class PublishViewset(ViewSet):
def list(self,request):
objects_filter = Publish.objects.filter()
serializer = PublishSerializer(instance=objects_filter,many=True)
return Response(data=serializer.data)
def add(self,request):
# 注意序列化器中 的第一个参数是 instance 第二个是 data，当没写时，默认从第一个开始
serializer = self.get_serializer(data=request.data)
serializer.is_valid(raise_exception=True)
serializer.save()
return Response(data=serializer.data)
def delete(self,request,pk):
''' 删除 '''
publish = self.get_object() # 查询单一
publish.delete()
return Response()
def get_by(self,request,pk):
objects_filter = Publish.objects.filter(pk=pk).first()
serializer = PublishSerializer(instance=objects_filter)
return Response(data=serializer.data)
def update(self,request,pk):
get_object = self.get_object()
serializer = self.get_serializer(get_object, request.data)
serializer.is_valid(raise_exception=True)
serializer.save()
return Response(data=serializer.data)
4.4GenericViewSet
from .views import *
from django.urls import path
urlpatterns = [
# 可以使用 路由器
# ViewSet
path('publish/',PublishViewset.as_view({'get':'list','post':'create'})),# 列表视图
# ViewSet
path('publish//' ,PublishViewset.as_view({'get':'retrieve','delete':'destroy','put':'update'})),# 详情视图
]
from rest_framework.viewsets import GenericViewSet
from rest_framework.response import Response
from .serializers import PublishSerializer
from .models import *
class PublishViewset(GenericViewSet):
queryset = Publish.objects.filter()
serializer_class = PublishSerializer
def list(self,request):
data_lis = self.get_queryset()
serializer = self.get_serializer(data_lis, many=True)
return Response(data=serializer.data)
def retrieve(self,request,pk):
''' 查询 单一'''
publish = self.get_object() # 查询单一
serializer = self.get_serializer(publish)
return Response(data=serializer.data)
def destroy(self,request,pk):
''' 删除 '''
publish = self.get_object() # 查询单一
publish.delete()
return Response()
def update(self,request,pk):
''' 修改 '''
get_object = self.get_object()
serializer = self.get_serializer(get_object, request.data)
serializer.is_valid(raise_exception=True)
serializer.save()
return Response(data=serializer.data)
def create(self,request):
''' 新增 '''
# 注意序列化器中 的第一个参数是 instance 第二个是 data，当没写时，默认从第一个开始
serializer = self.get_serializer(data=request.data)
serializer.is_valid(raise_exception=True)
serializer.save()
return Response(data=serializer.data)
1) GenericViewSet + Minxin
from .view_set_views import *
from django.urls import path
urlpatterns = [
# 可以使用 路由器
# GenericAPIView
path('publish/',PublishViewset.as_view({'get':'list','post':'create'})),# 列表视图
# GenericAPIView
path('publish//' ,PublishViewset.as_view({'get':'retrieve','delete':'destroy','put':'update'})),# 详情视图
]
from rest_framework.viewsets import GenericViewSet
from rest_framework.mixins import ListModelMixin,\
RetrieveModelMixin,\
CreateModelMixin,\
UpdateModelMixin,\
DestroyModelMixin
from rest_framework.response import Response
from .serializers import PublishSerializer
from .models import *
class PublishViewset(GenericViewSet,ListModelMixin,RetrieveModelMixin,CreateModelMixin,UpdateModelMixin,DestroyModelMixin):
# 由于 mixins 中 已经将重用的方法写了，不用在写 也可以自行重写。
queryset = Publish.objects.filter()
serializer_class = PublishSerializer
4.5 ModelViewSet
from rest_framework.viewsets import ModelViewSet
from .serializers import PublishSerializer
from .models import *
class PublishViewset(ModelViewSet):
''' ModelViewSet 已经继承了mixins中常用的内容 '''
queryset = Publish.objects.filter()
serializer_class = PublishSerializer
三、路由器
路由器只能配合视图一起使用
视图集：ViewSet、GenericViewSet 、ModelViewSet
rest_framework.routers.DefaultRouter
路由器只会生成默认的五个路由
其余的还需要自己手动加入
路由器使用方法：
from rest_framework.routers import DefaultRouter
urlpatterns = [] # 其他手动加入的路由内容
router = DefaultRouter()# 创建路由器
router.register('book',BookModelViewSet,basename='book')# 注册路由
urlpatterns += router.urls# 把生成好的路由拼接到urlpatterns中去
自定义增加的行为
@action(methods=[‘get’],detail=False)
action 中的参数
methods 表示的是 请求方式
detail 表示的是 路由生成方式；当detail=True 时会生成的url 则是 book/+ **PK/方法名/ ** 当 detail=False 时会生成 book/+ **方法名/ **
rest_framework.decorators.action
from django.db.models import Q
from rest_framework.viewsets import ModelViewSet
from rest_framework.decorators import action
from .serializers import BookSerializer
from .models import Book
from rest_framework.response import Response
class BookModelViewSet(ModelViewSet):
queryset = Book.objects.all()
serializer_class = BookSerializer
# datail 为 False 表示路径名格式应该为： books/get_book/
@action(methods=['get'],detail=False)
def get_book(self,request):
''' 查询 price 大于data['price']的书 '''
data = request.data
book_qy = Q(price__gt=data['price'])
book_list = Book.objects.filter(book_qy) # 工具id获取最后一本书
serializer = self.get_serializer(book_list,many=True)
return Response(serializer.data)
# datail 为 True 表示路径名格式应该为： books/pk/update_book_price/
@action(methods=['put'], detail=True)
def update_book_price(self,request,pk):
''' 修改某一本书的价格 '''
book_object = self.get_object()
book_object.price = request.data['price']
book_object.save()
serializer = self.get_serializer(book_object)
return Response(serializer.data)
''' urls.py '''
from .book_views import BookModelViewSet
from rest_framework.routers import DefaultRouter
urlpatterns = []
router = DefaultRouter()# 创建路由器
router.register('book',BookModelViewSet,basename='book')# 注册路由
urlpatterns += router.urls# 把生成好的路由拼接到urlpatterns中去
DefaultRouter
rest_framework.routers.DefaultRouter
SimpleRouter
rest_framework.routers.SimpleRouter
注意：
SinmpleRouter 和 DefaultRouter 只有一个区别，DefaultRouter 会多生成一个根路由