其他分享
首页 > 其他分享> > DjangoRestFramework使用总结

DjangoRestFramework使用总结

作者:互联网

你要去相信,没有到不了的明天。

摘要

本文主要描述DjangoRestFramework的相关内容,额外提及部分涉及到的其他知识。

简介

1.Django REST framework 框架是一个用于构建Web API的强大而又灵活的工具。通常简称为DRF框架 或 REST framework,DRF框架是建立在Django框架基础之上的。那为何要使用DjangoRestFramework,每个项目都需要做基础构架,这个时候需要考虑跟多的事情,包括

这时候,使用RestFramework能让我们快速并较好地完成这部分工作,进而进行其他事项的工。同样,在编码阶段,也能让我们的编码效率得到进一步提升。如:对于一个简单表的增、删、改、查,完全不需要我们自己去编码。

总而言之,使用RestFramework能进一步提升工作的效率,减少重复造轮子。

2.特点:

3.环境安装与配置:

pip install djangorestframework  #安装

其他配合使用的包和版本:

python3.6+
Django==2.2.13
django-filter==2.3.0
django-redis==4.12.1
djangorestframework==3.11.1

DRF是以Django扩展应用的方式提供的,所以可以直接利用已有的Django环境而无需重新创建。(若没有Django环境,需要先创建环境安装Django)

django配置文件settings.py(以具体项目为准)的INSTALLED_APPS中添加’rest_framework’。

INSTALLED_APPS = [    ...    'rest_framework',]

即可开始使用。

Django中的 FBV和CBV

Django有两种视图,分别为:

其中,FBV 是比较常见的,就是使用了函数来处理用户的请求;而 CBV是使用了类来处理用户的请求,是基于反射实现根据请求方式的不同,执行不同的方法。

原理:url -> view方法 -> dispatch方法(反射执行其他请求方式:GET/POST/PUT/DELETE)

更多解释:

1.Django 视图 - FBV 与 CBV

2.Django的CBV和FBV

认证

1.使用默认认证方案:

可以在配置文件中配置全局默认的认证方案

REST_FRAMEWORK = {
    'DEFAULT_AUTHENTICATION_CLASSES': (
        'rest_framework.authentication.BasicAuthentication',   # 基本表单认证
        'rest_framework.authentication.SessionAuthentication',  # session认证
    )
}

也可以在视图中通过设置authentication_classess属性来设置

from rest_framework.authentication import SessionAuthentication, BasicAuthentication
from rest_framework.views import APIView

class ExampleView(APIView):
    authentication_classes = (SessionAuthentication, BasicAuthentication)
    ...

认证失败会有两种可能的返回值:

2.RestFramework认证流程:

view中获取请求(request)-> dispatch函数进行反射 -> response, 其中,dispatch中有如下过程:

3.自定义认证类

from rest_framework.authentication import BaseAuthentication

class TestAuthentication(BaseAuthentication):

    def authenticate(self, request):
        ...
        return (result, token)

RestFramework还提供其他的认证类,如BasicAuthentication、SessionAuthentication、TokenAuthentication等,定义在rest_framework.authentication中。

权限

1.权限控制可以限制用户对于视图的访问和对于具体数据对象的访问。

2.使用:

可以在配置文件中设置默认的权限管理类,如

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,) #登录授权用户
    ...

3.自定义权限控制类

from rest_framework.permissions import BasePermission

class TestPermission(BasePermission):

    def has_permission(self, request, view):
        """
        Return `True` if permission is granted, `False` otherwise.
        """
        return True

    def has_object_permission(self, request, view, obj):
        """
        Return `True` if permission is granted, `False` otherwise.
        """
        return True

提供的权限控制类,在rest_framework.permissions中:

限流

1.可以对接口访问的频次进行限制,以减轻服务器压力,主要用于反爬虫。

2.使用:

可以在配置文件中,使用DEFAULT_THROTTLE_CLASSESDEFAULT_THROTTLE_RATES进行全局配置,

REST_FRAMEWORK = {
    'DEFAULT_THROTTLE_CLASSES': (
        'rest_framework.throttling.AnonRateThrottle',
        'rest_framework.throttling.UserRateThrottle'
    ),
    #DEFAULT_THROTTLE_RATES 可以使用 second, minute, hour 或day来指明周期。
    'DEFAULT_THROTTLE_RATES': {
        'anon': '5/day', # 匿名用户每天访问5次
        'user': '100/day'  # 登录用户访问100次
    }
}

也可以在具体视图中通过throttle_classes属性来配置,如

from rest_framework.throttling import UserRateThrottle
from rest_framework.views import APIView

class BookListView(APIView):    
	throttle_classes = (UserRateThrottle,)
    ...

3.自定义限流类

from rest_framework.throttling import BaseThrottle, SimpleRateThrottle

class TestThrottle(SimpleRateThrottle)

    scope = 'user'

    def get_cache_key(self, request, view):
        if request.user.is_authenticated:
            ident = request.user.pk
        else:
            ident = self.get_ident(request)

        return self.cache_format % {
            'scope': self.scope,
            'ident': ident
        }

# 一般继承SimpleRateThrottle,而不是BaseThrottle
class BaseThrottle:
    """
    Rate throttling of requests.
    """

    def allow_request(self, request, view):
        """
        Return `True` if the request should be allowed, `False` otherwise.
        """
        raise NotImplementedError('.allow_request() must be overridden')

可选限流类,定义在rest_framework.throttling中

1) AnonRateThrottle

限制所有匿名未认证用户,使用IP区分用户。

使用DEFAULT_THROTTLE_RATES['anon'] 来设置频次

2)UserRateThrottle

限制认证用户,使用User id 来区分。

使用DEFAULT_THROTTLE_RATES['user'] 来设置频次

3)ScopedRateThrottle

限制用户对于每个视图的访问频次,使用ip或user id。

版本

1.在给外部提供的API中,可会存在多个版本,为了区分不同版本,django rest framework提供了4种版本类供我们选择。

2.使用

在配置文件中全局配置

REST_FRAMEWORK = {
    # 版本控制
    "DEFAULT_VERSIONING_CLASS": 'rest_framework.versioning.URLPathVersioning',
    "ALLOWED_VERSIONS": ['v1', "v2"],
    "DEFAULT_VERSION": "v1"
    "VERSION_PARAM": "version"
    }

也可以在视图中指定

class ExampleView(APIView):
	versioning_class = "v1"

然后在url中编写相对应的url即可。

3.自定义版本控制类:

from rest_framework.versioning import (
    BaseVersioning,
    QueryParameterVersioning,
    URLPathVersioning 
)
# 一般直接使用内置的类,不需要自己写

class TestVersion(BaseVersioning):
    """
    自定义的version,通过get参数传参
    """
    def determine_version(self, request, *args, **kwargs):
        version = request.query_params.get('version')
        return version

过滤

1.对于列表数据可能需要根据字段进行过滤。

可以通过添加django-fitlter扩展来增强支持, 但过滤的视图应要求是实现了ListModelMixin扩展类及其子类的视图。

pip install django-filter

2.使用:

在配置文件中增加全局配置:

INSTALLED_APPS = [
    ...
    'django_filters',  # 需要注册应用,
]

REST_FRAMEWORK = {
    'DEFAULT_FILTER_BACKENDS': ('django_filters.rest_framework.DjangoFilterBackend',)
}

在视图中添加filterset_fields属性,指定可以过滤的字段

class BookListViewSet(ModelViewSet):
    queryset = BookInfo.objects.all()
    serializer_class = BookInfoSerializer
    filterset_fields = ('title', 'author')

3.自定义过滤类

from rest_framework.filters import BaseFilterBackend
from django_filters.rest_framework import DjangoFilterBackend

class MyBaseFilterBackend(BaseFilterBackend):

    def filter_queryset(self, request, queryset, view):
        """
        Return a filtered queryset.
        """
        ...
        return queryset

BaseFilterBackend定义在rest_framework.filters中,另外。通常使用django_filters.rest_framework中的DjangoFilterBackend类作为基础过滤类,支持 REST framework 高度自定义字段过滤。

4.使用 排序OrderingFilter

对于列表数据,REST framework提供了OrderingFilter过滤器来按照指定字段进行排序。同样要实现ListModelMixin扩展类及子类的视图才能使用。

注意:如果在视图上未指定 ordering_fields 属性,则过滤器类将默认允许用户过滤由 serializer_class 属性指定的序列化器中的任何可读字段,所以最好指定,避免数据泄漏。

5.使用SearchFilter过滤类

SearchFilter 类支持简单的基于单个查询参数的搜索,并且基于 Django 管理员的搜索功能

class UserListView(generics.ListAPIView):
    queryset = User.objects.all()
    serializer_class = UserSerializer
    filter_backends = (filters.SearchFilter,)
    search_fields = ('username', 'email')

这将允许客户端通过查询来过滤列表中的项,例如:

http://example.com/api/users?search=russell

还可以使用查找 API 双下划线表示法对 ForeignKey 或 ManyToManyField 执行相关查找:

search_fields = ('username', 'email', 'profile__profession')

默认情况下,搜索将使用不区分大小写的部分匹配。搜索参数可能包含多个搜索项,它们应该是空格和/或逗号分隔的。如果使用多个搜索项,则只有在所有提供的项匹配的情况下,对象才会返回到列表中。

可以通过在 search_fields 之前添加各种字符来限制搜索行为。

举个栗子:

search_fields = ('=username', '=email')

默认情况下,搜索参数被命名为 'search',但这可能会被 SEARCH_PARAM 设置覆盖。

更多:过滤 (Filtering)

解析器

1.REST framework 提供了Parser解析器,在接收到请求后会自动根据Content-Type指明的请求数据类型(如JSON、表单等)将请求数据进行parse解析,解析为类字典对象保存到Request对象中。

注意:Request对象的数据是自动根据前端发送数据的格式进行解析之后的结果(上文中认证流程提到了对原生request进行进行一步封装,其中的parsers就是指解析器)

值得一提的是,无论前端发送的哪种格式的数据,我们只需要使用以下两种方式读取数据:

1)request.data

request.data 返回解析之后的请求体(表单、json)数据。类似于Django中标准的request.POSTrequest.FILES属性,但提供如下特性:

2)query_params

request.query_params与Django标准的request.GET相同,用于获取查询字符串,只是更换了更正确的名称而已。

2.使用:

在配置文件中全局定义:

REST_FRAMEWORK = {
	...
	'DEFAULT_PARSER_CLASSES': {
        	'rest_framework.parsers.JSONParser',
    	}
}

在视图中添加parser_classes

from rest_framework.versioning import URLPathVersioning
from rest_framework.parsers import JSONParser
class UserView(APIView):
    '''查看用户信息'''
    parser_classes = [JSONParser,]
    versioning_class =URLPathVersioning

    def get(self,request,*args,**kwargs):
        res={"name":"wd","age":22}
        return JsonResponse(res,safe=True)
    
    def post(self,request,*args,**kwargs):
        print(request.data) #获取解析后的请求结果
        return JsonResponse({"success":"ok"}, safe=True)

3.可使用的解析类(不用自己定义或重写,直接使用就好)

在当前实际使用中,基本没有手动去指定使用哪一种或哪几种解析类。

序列化

1.序列化器允许将复杂数据 (如查询集和模型实例) 转换为可以轻松渲染成 JSONXML 或其他内容类型的原生 Python 数据类型。序列化器还提供反序列化,在验证传入的数据之后允许解析数据转换回复杂类型。

序列化器的作用:

注意:serializer不是只能为数据库模型类定义,也可以为非数据库模型类的数据定义。

现在创建一个类(非数据库模型类)

from datetime import datetime

class Comment(object):
    def __init__(self, email, content, created=None):
        # 三个字段
        self.email = email
        self.content = content
        self.created = created or datetime.now()

comment = Comment(email='leila@example.com', content='foo bar')

序列化的声明如下:

from rest_framework import serializers

class CommentSerializer(serializers.Serializer):
	# 对应上面定义的三个字段
    email = serializers.EmailField()
    content = serializers.CharField(max_length=200)
    created = serializers.DateTimeField()

这样便可以通过序列化类,实现 Python 原生的数据类型(这里是comment对象)与Json格式数据的相互转换。

# 序列化
serializer = CommentSerializer(comment)
# 序列化后的json数据
serializer.data

# 反序列化(json格式数据转回Comment类对象类型)
serializer = CommentSerializer(data=data)
# 验证
serializer.is_valid()
serializer.validated_data

2.关联对象嵌套序列化

1) PrimaryKeyRelatedField

此字段将被序列化为关联对象的主键。属性使用related_name的值,如果没有则使用关联类小写_set(heroinfo_set)

user = serializers.PrimaryKeyRelatedField( read_only=True)
  1. StringRelatedField

此字段将被序列化为关联对象的字符串表示方式(即关联模型类__str__方法的返回值)

3)使用关联对象的序列化器

user = UserInfoSerializer(many=True)  # 根据指定的UserInfoSerialzier序列化中指定的字段返回

3.反序列化

验证成功,可以通过序列化器对象的validated_data属性获取数据。

4.自定义验证

序列化的is_valid()方法提供的验证只能验证对应的字段和类型,对应一些额外的验证需要我们自己去实现

1)验证单一字段

class BookInfoSerializer(serializers.Serializer):
    # 方法名定义为validated_字段名
    def validated_btitle(self, value):
    if value == 'python':
    	raise serializers.ValidationError('书名python错误')
    return value

2)验证多个字段

class BookInfoSerializer(serializers.Serializer):
	# 方法名定义为validate
    def validate(self, attrs):
        bread = attrs['bread']
        bcomment = attrs['bcomment']
        if bread < bcomment:
            raise serializers.ValidationError('阅读量小于评论量')
        return attrs

5.保存数据

如果在验证成功后,想要基于validated_data类属性完成数据对象的创建,可以通过实现create()update()两个方法来实现。

class BookInfoSerializer(serializers.Serializer):
    """图书数据序列化器"""
    ...

    def create(self, validated_data):
        """新建"""
        return BookInfo.objects.create(**validated_data)

    def update(self, instance, validated_data):
        """更新,instance为要更新的对象实例"""
        instance.btitle = validated_data.get('btitle', instance.btitle)
        instance.bpub_date = validated_data.get('bpub_date', instance.bpub_date)
        instance.bread = validated_data.get('bread', instance.bread)
        instance.bcomment = validated_data.get('bcomment', instance.bcomment)
        # 存入数据库
        instance.save()
        return instance

注:如果创建序列化器对象的时候,没有传递instance实例,则调用save()方法的时候,create()被调用,相反,如果传递了instance实例,则调用save()方法的时候,update()被调用。

6.模型类序列化器ModelSerializer

如果我们想要使用序列化器对应的是Django的模型类,DRF为我们提供了ModelSerializer模型类序列化器来帮助我们快速创建一个Serializer类。

ModelSerializer与常规的Serializer相同,但提供了:

1)定义

要使用要继承serializers.ModelSerializer

比如我们创建一个BookInfoSerializer:

class BookInfoSerializer(serializers.ModelSerializer):
    """图书数据序列化器"""
    class Meta:
        model = BookInfo
        # 返回所有字段
        fields = '__all__'
        # 返回特定字段
        # fields = ['id', 'name']
        # 除去特定字段
        # exclude = ['id']

2)可以在django环境中执行python manage.py shell命令来查看自动生成的BookInfoSerializer的具体实现。

>>> from booktest.serializers import BookInfoSerializer
>>> serializer = BookInfoSerializer()
>>> serializer
BookInfoSerializer():
    id = IntegerField(label='ID', read_only=True)
    btitle = CharField(label='名称', max_length=20)
    bpub_date = DateField(allow_null=True, label='发布日期', required=False)
    bread = IntegerField(label='阅读量', max_value=2147483647, min_value=-2147483648, required=False)
    bcomment = IntegerField(label='评论量', max_value=2147483647, min_value=-2147483648, required=False)
    image = ImageField(allow_null=True, label='图片', max_length=100, required=False)

3)添加额外参数

可以使用**extra_kwargs**参数为ModelSerializer添加或修改原有的选项参数

分页

1.使用:

配置文件中设置全局的分页方式,如:

REST_FRAMEWORK = {
    'DEFAULT_PAGINATION_CLASS':  'rest_framework.pagination.PageNumberPagination',
    'PAGE_SIZE': 5  # 每页数目
}

也可在视图中通过pagination_class属性来指明。

from rest_framework.pagination import PageNumberPagination
    
class BookDetailViewSet(ModelViewSet):
    queryset = BookInfo.objects.all()
    serializer_class = BookInfoSerializer
    pagination_class = PageNumberPagination

注意:如果在视图内关闭分页功能,只需在视图内设置

pagination_class = None

2.自定义分页类:

from rest_framework.pagination import PageNumberPagination

class StandardPageNumberPagination(PageNumberPagination):
    page_size_query_param = 'page_size'
    max_page_size = 10

class BookDetailViewSet(ModelViewSet):
    queryset = BookInfo.objects.all()
    serializer_class = BookInfoSerializer
    pagination_class = StandardPageNumberPagination

3.DjangoRestFramework提供了三种分页组件:

  1. PageNumberPagination:普通分页,查看第n页,每个页面显示n条数据。可以在子类中定义的属性:

2)LimitOffsetPagination:基于位置的分页,在第n个位置,向后查看n条数据,和数据库的sql语句中的limit offset类似,参数offet代表位置,limit代表取多少条数据。可以在子类中定义的属性:

3)CursorPagination:游标分页,意思就是每次返回当前页、上一页、下一页,并且每次的上一页和下一页的url是不规则的。

视图

B0X6II.png

APIView

1.APIView是REST framework提供的所有视图的基类,继承自Django的View父类。

2.APIViewView的不同之处在于:

3.支持定义的属性:

APIView中仍以常规的类视图定义方法来实现get() 、post() 或者其他请求方式的方法。

from rest_framework.views import APIView
from rest_framework.response import Response
# url配置写法
# 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)

GenericAPIView

rest_framework.generics.GenericAPIView继承自APIVIew,增加了对于列表视图和详情视图可能用到的通用支持方法。通常使用时,可搭配一个或多个Mixin扩展类。

1.支持定义的属性:

1)列表视图与详情视图通用:

2)列表视图使用:

3)详情页视图使用:

2.提供的方法:

1)列表视图与详情视图通用:

2)详情视图使用:

五个扩展类

1.ListModelMixin

列表视图扩展类,提供list(request, *args, **kwargs)方法快速实现列表视图,返回200状态码。

class ListModelMixin:
    """
    List a queryset.
    """
    def list(self, request, *args, **kwargs):
        queryset = self.filter_queryset(self.get_queryset())

        page = self.paginate_queryset(queryset)
        if page is not None:
            serializer = self.get_serializer(page, many=True)
            return self.get_paginated_response(serializer.data)

        serializer = self.get_serializer(queryset, many=True)
        return Response(serializer.data)

2.CreateModelMixin

创建视图扩展类,提供create(request, *args, **kwargs)方法快速实现创建资源的视图,成功返回201状态码。如果序列化器对前端发送的数据验证失败,返回400错误。

class CreateModelMixin:
    """
    Create a model instance.
    """
    def create(self, request, *args, **kwargs):
        serializer = self.get_serializer(data=request.data)
        serializer.is_valid(raise_exception=True)
        self.perform_create(serializer)
        headers = self.get_success_headers(serializer.data)
        return Response(serializer.data, status=status.HTTP_201_CREATED, headers=headers)

    def perform_create(self, serializer):
        serializer.save()

    def get_success_headers(self, data):
        try:
            return {'Location': str(data[api_settings.URL_FIELD_NAME])}
        except (TypeError, KeyError):
            return {}

3.RetrieveModelMixin

详情视图扩展类,提供retrieve(request, *args, **kwargs)方法,可以快速实现返回一个存在的数据对象。如果存在,返回200, 否则返回404。

class RetrieveModelMixin:
    """
    Retrieve a model instance.
    """
    def retrieve(self, request, *args, **kwargs):
        instance = self.get_object()
        serializer = self.get_serializer(instance)
        return Response(serializer.data)

4.UpdateModelMixin

更新视图扩展类,提供update(request, *args, **kwargs)方法,可以快速实现更新一个存在的数据对象。同时也提供partial_update(request, *args, **kwargs)方法,可以实现局部更新。成功返回200,序列化器校验数据失败时,返回400错误。

class UpdateModelMixin:
    """
    Update a model instance.
    """
    def update(self, request, *args, **kwargs):
        partial = kwargs.pop('partial', False)
        instance = self.get_object()
        serializer = self.get_serializer(instance, data=request.data, partial=partial)
        serializer.is_valid(raise_exception=True)
        self.perform_update(serializer)

        if getattr(instance, '_prefetched_objects_cache', None):
            # If 'prefetch_related' has been applied to a queryset, we need to
            # forcibly invalidate the prefetch cache on the instance.
            instance._prefetched_objects_cache = {}

        return Response(serializer.data)

    def perform_update(self, serializer):
        serializer.save()

    def partial_update(self, request, *args, **kwargs):
        kwargs['partial'] = True
        return self.update(request, *args, **kwargs)

5.DestroyModelMixin

删除视图扩展类,提供destroy(request, *args, **kwargs)方法,可以快速实现删除一个存在的数据对象。成功返回204,不存在返回404。

class DestroyModelMixin:
    """
    Destroy a model instance.
    """
    def destroy(self, request, *args, **kwargs):
        instance = self.get_object()
        self.perform_destroy(instance)
        return Response(status=status.HTTP_204_NO_CONTENT)

    def perform_destroy(self, instance):
        instance.delete()

RestFramework根据GenericAPIView和五个扩展类提供了一些可用的视图,如:

# 源码,这里例举三个,其他的类似
class CreateAPIView(mixins.CreateModelMixin,
                    GenericAPIView):
    """
    Concrete view for creating a model instance.
    """
    def post(self, request, *args, **kwargs):
        return self.create(request, *args, **kwargs)
    
class UpdateAPIView(mixins.UpdateModelMixin,
                    GenericAPIView):
    """
    Concrete view for updating a model instance.
    """
    def put(self, request, *args, **kwargs):
        return self.update(request, *args, **kwargs)

    def patch(self, request, *args, **kwargs):
        return self.partial_update(request, *args, **kwargs)


class ListCreateAPIView(mixins.ListModelMixin,
                        mixins.CreateModelMixin,
                        GenericAPIView):
    """
    Concrete view for listing a queryset or creating a model instance.
    """
    def get(self, request, *args, **kwargs):
        return self.list(request, *args, **kwargs)

    def post(self, request, *args, **kwargs):
        return self.create(request, *args, **kwargs)

可根据实际需要进行选取,然后继承实现对应功能。

视图集

B0jiJx.png

ViewSet

1.使用视图集ViewSet,可以将一系列逻辑相关的动作放到一个类中:

ViewSet视图集类不再实现get()、post()等方法,而是实现动作 action 如 list() 、create() 等。

class BookInfoViewSet(viewsets.ViewSet):

    def list(self, request):
        ...

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

设置路由(视图集只在使用as_view()方法的时候,才会将action动作与具体请求方式对应上)如:

urlpatterns = [
    url(r'^books/$', BookInfoViewSet.as_view({'get':'list'}),
    url(r'^books/(?P<pk>\d+)/$', BookInfoViewSet.as_view({'get': 'retrieve'})
]

2.action属性

视图集中,我们可以通过action对象属性来获取当前请求视图集时的action动作是哪个,通常通过action来区分使用的序列化类,如:

def get_serializer_class(self):
    if self.action == 'create':
        return BookInfoSerializer
    else:
        return BookDetialInfoSerializer

视图集类

1.ViewSet

继承自APIViewViewSetMixin,作用与APIView基本类似,提供了身份认证、权限校验、流量管理等。

在ViewSet中,没有提供任何动作action方法,需要自己实现action方法。而ViewSetMixin类的as_view方法设置了类的action属性,并将我们定义的action方法与请求方式进行绑定, 存于action_map属性(字典)中。

2.GenericViewSet

继承自GenericAPIView,作用也与GenericAPIVIew类似,提供了get_object、get_queryset等方法便于列表视图与详情信息视图的开发。

3.ReadOnlyModelViewSet

继承自GenericAPIVIew,同时包括了ListModelMixin、RetrieveModelMixin。

4.ModelViewSet

继承自GenericAPIVIew,同时包括了ListModelMixin、RetrieveModelMixin、CreateModelMixin、UpdateModelMixin、DestoryModelMixin。即所有增删改查功能都具备。

路由

1.对于视图集ViewSet,除了可以自己手动指明请求方式与动作action之间的对应关系外,还可以使用Routers来快速实现路由信息。

REST framework提供了两个router

SimpleRouterDefaultRouter的区别在于后者能生成首页(方便查看所有接口 ),而前者不能。

2.使用:

1) 创建router对象,并注册视图集,例如

from rest_framework import routers

router = routers.SimpleRouter()
router.register(r'books', BookInfoViewSet, base_name='book')

register(prefix, viewset, base_name)

如上述代码会形成的路由如下:

^books/$    name: book-list
^books/{pk}/$   name: book-detail

2)添加路由数据

可以有两种方式:

urlpatterns = [ ... ]
urlpatterns += router.urls复制代码

urlpatterns = [    ..., url(r'^', include(router.urls))]

这种方式只会生成视图集扩展类里面定义的方法,对于自定义的方法不能生成。

3)视图集中包含附加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 read(self, request, pk):
        ...

    @action(methods=['put'], detail=True)#detail = True生成正则匹配
    def modify(self, request, pk):
        ...

此视图集会形成的路由:

^books/read/$    name: book-read
^books/{pk}/modify/$  name: book-modify

注意:要使用自动生成路由的方法,视图必须继承自视图集。

TODO:使用视图集只能处理前端通过request发过来的数据是表单或json数据的类型。

3.几种常用的路由写法

from django.conf.urls import url,include

# APIView类型的url
url(r'^api/v1/users/', views.UserView.as_view())

# ViewSet类型的url,对请求方法进行映射
url(r'^api/v1/users/', views.UserView.as_view({'get':'list','post':'create'}))
url(r'^api/v1/users/(?P<pk>\d+)$', views.UserView.as_view({'get':'retrieve','delete':'destroy','put':'update','patch':'partial_update'})),

# 使用路由器
from rest_framework import routers
router=routers.DefaultRouter() #是列化router类
router.register(r'userinfo$',views.UserView)  #注册一个url,后续会生成我们想要的个url
urlpatterns = [
    url(r'^api/v1/',include(router.urls)),#将生成的url加入到路由中
]

响应

1.REST framework提供了一个响应类Response,使用该类构造响应对象时,响应的具体数据内容会被转换(render渲染)成符合前端需求的类型。

Response(self, data=None, status=None, template_name=None, exception=False, headers=None, content_type=None)

参数说明:

2.状态码:

REST framewrokrest_framework.status模块中提供了常用状态码常量。常用的几个:

HTTP_200_OK = 200
HTTP_201_CREATED = 201
HTTP_202_ACCEPTED = 202
HTTP_302_FOUND = 302
HTTP_400_BAD_REQUEST = 400
HTTP_401_UNAUTHORIZED = 401
HTTP_403_FORBIDDEN = 403
HTTP_404_NOT_FOUND = 404
HTTP_500_INTERNAL_SERVER_ERROR = 500

异常处理

1.使用:

采用默认的方式,如下

REST_FRAMEWORK = {
    'EXCEPTION_HANDLER': 'rest_framework.views.exception_handler' 
}

在配置文件中声明自定义的异常处理

REST_FRAMEWORK = {
    'EXCEPTION_HANDLER': 'my_project.my_app.utils.custom_exception_handler'#定义处理异常的路径,以项目实际为准
}

2.自定义异常处理

REST framework提供了异常处理,可以自定义异常处理函数。

from rest_framework.views import exception_handler
from rest_framework import status
from django.db import DatabaseError

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
        view = context['view']
        # 数据库的异常
        if isinstance(exc, DatabaseError):
            print('[%s]: %s' % (view, exc))
            response = Response({'detail': '服务器内部错误'}, status=status.HTTP_507_INSUFFICIENT_STORAGE)

    return response

3.REST framework定义的异常

参考

1.官方文档

2.中文文档

3.Django Rest Framework

4.Django REST framework的使用总结

5.Django Rest Framework记录

6.Django REST framework的各种技巧

标签:总结,self,request,视图,framework,DjangoRestFramework,使用,序列化,class
来源: https://blog.csdn.net/asdf_yuanfang/article/details/121915368