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)

rest_framework_django 学习笔记二(视图路由)_第1张图片

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)

rest_framework_django 学习笔记二(视图路由)_第2张图片

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)

rest_framework_django 学习笔记二(视图路由)_第3张图片

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)

rest_framework_django 学习笔记二(视图路由)_第4张图片

增删查改代码全

''' 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_django 学习笔记二(视图路由)_第5张图片

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()),# 详情视图
]

rest_framework_django 学习笔记二(视图路由)_第6张图片

其他扩展
  • 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)

rest_framework_django 学习笔记二(视图路由)_第7张图片

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()

rest_framework_django 学习笔记二(视图路由)_第8张图片

rest_framework_django 学习笔记二(视图路由)_第9张图片

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'})),# 详情视图
]

rest_framework_django 学习笔记二(视图路由)_第10张图片

继承自 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

rest_framework_django 学习笔记二(视图路由)_第11张图片

2.3ReadOnlyModelViewSet

rest_framework_django 学习笔记二(视图路由)_第12张图片

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

rest_framework_django 学习笔记二(视图路由)_第13张图片

2.4ModelViewSet

rest_framework.viewsets.ModelViewSet

rest_framework_django 学习笔记二(视图路由)_第14张图片

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)

rest_framework_django 学习笔记二(视图路由)_第15张图片

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

rest_framework_django 学习笔记二(视图路由)_第16张图片

三、路由器

路由器只能配合视图一起使用

视图集: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中去

rest_framework_django 学习笔记二(视图路由)_第17张图片

DefaultRouter

rest_framework.routers.DefaultRouter

SimpleRouter

rest_framework.routers.SimpleRouter

注意:

SinmpleRouter 和 DefaultRouter 只有一个区别,DefaultRouter 会多生成一个根路由

其他笔记

序列化器

视图路由

异常、登录认证

你可能感兴趣的:(django,学习,笔记)