Django Rest Framework

什么是Restful
REST代表的是一种软件架构风格，REST是Representational State Transfer的简称，中文翻译为“表征状态转移”。
REST从资源的角度类审视整个网络，将分布的网络中某个节点的资源通过URL进行标识，客户端应用通过URL来获取资源的表征，获得这些表征只是这些应用转变状态。
所有的数据，无论是通过网络获取的还是操作(增删改查)的数据，都是资源，将一切数据视为资源是REST区别其他架构风格的最本质属性。
对于REST这种面向资源的架构风格，即：面向资源架构（ROA：Resource Oriented Architecture）。

Restful API设计规范
　　-API与用户的通信协议，总是使用HTTPs协议
　　-域名
　　　　应该尽量将API部署在专用域名之下,如：https://api.example.com
　　　　如果确定API很简单也可以放在主域名下：https://example.org/api/
　　-版本
　　　　应将API的版本号放入URL
　　　　https://api.example.com/v1/
　　　　方法有很多，可将版本号放在HTTP头信息中，但不如放入URL方便和直观
　　-路径 网络上的任何东西都是资源，均使用名词表示(可复数)
　　　　https://api.example.com/v1/zoos
　　　　https://api.example.com/v1/animals
　　-HTTP动词
　　　　对资源的具体操作类型，有HTTP动词表示，常用的HTTP动词有下面五种（括号为sql命令）
　　　　GET （SELECT）：从服务器取出资源（一项或多项）
　　　　POST （CREATE）：在服务器新建一个资源
　　　　PUT （UPDATE）：在服务器更新资源（客户端提供改变后的完整资源）
　　　　PATCH （UPDATE）：在服务器更新资源（客户端提供改变的属性）
　　　　DELETE （DELETE）：从服务器删除资源
　　　　下面是一些例子。
　　　　GET /zoos：列出所有动物园
　　　　POST /zoos：新建一个动物园
　　　　GET /zoos/ID：获取某个指定动物园的信息
　　　　PUT /zoos/ID：更新某个指定动物园的信息（提供该动物园的全部信息）
　　　　PATCH /zoos/ID：更新某个指定动物园的信息（提供该动物园的部分信息）
　　　　DELETE /zoos/ID：删除某个动物园
　　　　GET /zoos/ID/animals：列出某个指定动物园的所有动物
　　　　DELETE /zoos/ID/animals/ID：删除某个指定动物园的指定动物
　　-过滤 如果记录数据很多，服务器不可能将它们返回给用户，API应提供参数过滤返回
　　　　https://api.example.com/v1/zoos?limit=10：指定返回记录的数量
　　　　https://api.example.com/v1/zoos?offset=10：指定返回记录的开始位置
　　　　https://api.example.com/v1/zoos?page=2&per_page=100：指定第几页，以及每页的记录数
　　　　https://api.example.com/v1/zoos?sortby=name&order=asc：指定返回结果按照哪个属性排序，以及排序顺序
　　　　https://api.example.com/v1/zoos?animal_type_id=1：指定筛选条件
　　　　参数的设计允许存在冗余，即允许API路径和URL参数偶尔有重复。比如，GET /zoo/ID/animals 与 GET /animals?zoo_id=ID 的含义是相同的
　　-状态码 服务器向用户返回的状态码和提示信息，常见的有以下一些（方括号中是该状态码对应的HTTP动词）。
　　　　200 OK - [GET]：服务器成功返回用户请求的数据，该操作是幂等的（Idempotent）。
　　　　201 CREATED - [POST/PUT/PATCH]：用户新建或修改数据成功。
　　　　202 Accepted - [*]：表示一个请求已经进入后台排队（异步任务）
　　　　204 NO CONTENT - [DELETE]：用户删除数据成功。
　　　　400 INVALID REQUEST - [POST/PUT/PATCH]：用户发出的请求有错误，服务器没有进行新建或修改数据的操作，该操作是幂等的。
　　　　401 Unauthorized - [*]：表示用户没有权限（令牌、用户名、密码错误）。
　　　　403 Forbidden - [*] 表示用户得到授权（与401错误相对），但是访问是被禁止的。
　　　　404 NOT FOUND - [*]：用户发出的请求针对的是不存在的记录，服务器没有进行操作，该操作是幂等的。
　　　　406 Not Acceptable - [GET]：用户请求的格式不可得（比如用户请求JSON格式，但是只有XML格式）。
　　　　410 Gone -[GET]：用户请求的资源被永久删除，且不会再得到的。
　　　　422 Unprocesable entity - [POST/PUT/PATCH] 当创建一个对象时，发生一个验证错误。
　　　　500 INTERNAL SERVER ERROR - [*]：服务器发生错误，用户将无法判断发出的请求是否成功。

　　-错误处理
　　　　{
　　　　　　code:123456,
　　　　　　error:"error info"
　　　　}
　　-返回结果 针对不同操作，服务器向用户返回的结果应符合以下规范
　　　　GET /collection：返回资源对象的列表（数组）
　　　　GET /collection/resource：返回单个资源对象
　　　　POST /collection：返回新生成的资源对象
　　　　PUT /collection/resource：返回完整的资源对象
　　　　PATCH /collection/resource：返回完整的资源对象
　　　　DELETE /collection/resource：返回一个空文档
　　-Hypermedia API
　　　　RESTful API最好做到Hypermedia，即返回结果中提供链接，连向其他API方法，使得用户不查文档，也知道下一步应该做什么。
　　　　比如，当用户向api.example.com的根目录发出请求，会得到这样一个文档。
　　　　{"link": {
　　　　　　"rel": "collection https://www.example.com/zoos",
　　　　　　"href": "https://api.example.com/zoos",
　　　　　　"title": "List of zoos",
　　　　　　"type": "application/vnd.yourformat+json"
　　　　}}

基于Django实现

路由系统
    urlpatterns = [
        url(r'^users', Users.as_view()),
    ]
CBV视图
    from django.views import View
    from django.http import JsonResponse
     
    class Users(View):
        def get(self, request, *args, **kwargs):
            result = {
                'status': True,
                'data': 'response data'
            }
            return JsonResponse(result, status=200)
     
        def post(self, request, *args, **kwargs):
            result = {
                'status': True,
                'data': 'response data'
            }
            return JsonResponse(result, status=200)

基于Django Rest Framework框架实现

1.序列化

自定义序列化类

 

from rest_framework import serializers
    class PublishSerializers(serializers.Serializer):
        name = serializers.CharField()
        email = serializers.CharField()

自定义外键关联序列化类

     class BookSerializers(serializers.Serializer):
         title = serializers.CharField(max_length=32)
         price = serializers.IntegerField()
         pub_date = serializers.DateField()
         publish=serializers.CharField(source="publish.name")#一对多字段
         #authors=serializers.CharField(source="authors.all")
         authors = serializers.SerializerMethodField()#多对多字段
         def get_authors(self,obj):#get_authors return的数据就是返回的json中authors值
             temp=[]
             for obj in obj.authors.all():
                 temp.append(obj.name)
             return temp
    # '''
    # 序列化BookSerializers(book_list,many=True)过程：
    #      temp=[]
    #      for obj in book_list:
    #          temp.append({
    #             "title":obj.title,
    #             "price":obj.price,
    #             "pub_date":obj.pub_date,
    #             "publish":str(obj.publish), # obj.publish.name
    #             #"authors":obj.authors.all,
    #             "authors": get_authors(obj)
    #          })
    # '''

view

    class PublishView(APIView):
        def get(self,request):
            '''序列化'''
            # 方式1：queryset对象通过list()转换成json对象
            # publish_list=list(Publish.objects.all().values("name","email"))
            # return HttpResponse(json.dumps(publish_list))

            # 方式2：model_to_dict把一个model对象转换成字段的方法
            # from django.forms.models import model_to_dict
            # publish_list=Publish.objects.all()
            # temp=[]
            # for obj in publish_list:
            #     temp.append(model_to_dict(obj))
            # return HttpResponse(json.dumps(temp))

            # 方式3：通过Django的序列化组件serializers（和rest_framework没关系）
            # from django.core import serializers
            # publish_list=Publish.objects.all()
            # ret=serializers.serialize("json",publish_list)
            # return HttpResponse(ret)

            # 方式4 rest_framework对queryset和model对象序列化(通过自定义序列化类实现)
            publish_list = Publish.objects.all()
            ps = PublishSerializers(publish_list, many=True)
            # many=True 声明是queryset多条数据,默认many=Flase
            return HttpResponse(ps.data)

        def post(self,request):
            print("request.data",request.data)
            return HttpResponse("POST")

单条数据序列化

路由部分
    urlpatterns = [
        path('books/',views.BookView.as_view(),name="books"),
        re_path(r'^books/(\d+)/$',views.BookDetailView.as_view(),name="detailbook"),
    ]
    视图部分
    class BookModelSerializers(serializers.ModelSerializer):
        class Meta:
            model = Book
            fields = "__all__"
        
        #HyperlinkedIdentityField属性 获取对应的链接地址 {"publish": "http://127.0.0.1:8000/publishes/3/"}
        #view_name 通过函数的name获取url lookup_field 传入的id  lookup_url_kwarg id替换的位置
        publish = serializers.HyperlinkedIdentityField(
            view_name="detailpublish",
            lookup_field="publish_id",
            lookup_url_kwarg="pk"
        )
        
    class BookDetailView(APIView):
    # 单条数据操作
    def get(self,request,id):
        book=Book.objects.filter(pk=id).first()
        bs=BookModelSerializers(book)#model对象不用加many
        return Response(bs.data)
    def put(self,request,id):
        book=Book.objects.filter(pk=id).first()
        bs=BookModelSerializers(book,data=request.data,context={'request': request})
        #序列化类传入model对象和前端提交的数据
        #序列化类可以双向数据转换
        if bs.is_valid():
            bs.save()
            return Response(bs.data)
        else:
            return Response(bs.errors)
    def delete(self,request,id):
        Book.objects.filter(pk=id).delete()
        return Response()

视图mixins

路由部分
        urlpatterns = [
            path('authors/',views.AuthorView.as_view(),name="author"),
            re_path(r'^authors/(?P<pk>\d+)/$',views.AuthorDetailView.as_view(),name="detailauthor"),
        ]
        
        视图部分
        class AuthorModelSerializers(serializers.ModelSerializer):
            class Meta:
                model = Author
                fields = "__all__"
        一.
        # from rest_framework import mixins
        # from rest_framework import generics
        # class AuthorView(mixins.ListModelMixin,mixins.CreateModelMixin,generics.GenericAPIView):
        #     #指定queryset，serializers为queryset对象和序列画的类，且名称固定
        #     queryset=Author.objects.all()
        #     serializer_class=AuthorModelSerializers
        #
        #     def get(self,request,*args,**kwargs):
        #         return self.list(request,*args,**kwargs)
        #     def post(self,request,*args,**kwargs):
        #         return self.create(request,*args,**kwargs)
        #
        #
        # class AuthorDetailView(mixins.RetrieveModelMixin, mixins.DestroyModelMixin, mixins.UpdateModelMixin,
        #                        generics.GenericAPIView):
        #     queryset = Author.objects.all()
        #     serializer_class = AuthorModelSerializers
        #     def get(self, request, *args, **kwargs):
        #         return self.retrieve(request,*args,**kwargs)
        #     def delete(self,request,*args,**kwargs):
        #         return self.destroy(request,*args,**kwargs)
        #     def put(self,request,*args,**kwargs):
        #         return self.retrieve(request,*args,**kwargs)
        二.对上面的进一步封装
        # from rest_framework import mixins
        # from rest_framework import generics
        #
        # class AuthorView(generics.ListCreateAPIView):
        #     queryset=Author.objects.all()
        #     serializer_class =AuthorModelSerializers
        #
        # class AuthorDetailView(generics.RetrieveUpdateDestroyAPIView):
        #     queryset = Author.objects.all()
        #     serializer_class = AuthorModelSerializers
viewsets(更进一步的封装)
    
    路由部分
    urlpatterns = [
        path('authors/',views.AuthorModelView.as_view({"get":"list","post":"create"}),name="author"),
        re_path(r'^authors/(?P<pk>\d+)/$',views.AuthorModelView.as_view({"get":"retrieve","put":"update","delete":"destroy"}),name="detailauthor"),
    ]
    
    视图部分
    class AuthorModelSerializers(serializers.ModelSerializer):
        class Meta:
            model = Author
            fields = "__all__"
    
    from rest_framework import viewsets

    class AuthorModelView(viewsets.ModelViewSet):
        queryset = Author.objects.all()
        serializer_class = AuthorModelSerializers

    # def list(self,request,*args,**kwargs):
    #     #自定义方法
    #     pass

2.登录

#用户登录成功会创建或更新token值
    def get_random_str(user):
        #根据用户名和时间返回随机字token值
        import hashlib,time
        ctime=str(time.time())
        md5=hashlib.md5(bytes(user,encoding="utf8"))
        md5.update(bytes(ctime,encoding="utf8"))
        return md5.hexdigest()

    class LoginView(APIView):
        def post(self,request):
            name=request.data.get("name")
            pwd=request.data.get("pwd")
            user=User.objects.filter(name=name,pwd=pwd).first()
            res = {"state_code":1000,"msg":None}
            if user:
                random_str=get_random_str(user.name)
                Token.objects.update_or_create(user=user,defaults={"token":random_str})
                res["token"]=random_str
            else:
                res["state_code"]=1001
                res["msg"]="用户名密码错误"
            return Response(json.dumps(res,ensure_ascii=False))

3.权限组件

#自定义认证类
    from rest_framework import exceptions
    from rest_framework.authentication import BaseAuthentication
    class TokenAuth(BaseAuthentication):
        def authenticate(self,request):
            token = request.GET.get("token")
            token_obj = Token.objects.filter(token=token).first()
            if not token_obj:
                raise exceptions.AuthenticationFailed("验证失败123!")
            else:
                return token_obj.user.name,token_obj.token

        #继承了BaseAuthentication所有下面可以注释
        # def authenticate_header(self, request):
        #     pass
    
    #局部认证
    class BookView(APIView):
        authentication_classes = [TokenAuth,]
    
    #全局认证
    setting.py
    
    REST_FRAMEWORK = {
        "DEFAULT_AUTHENTICATION_CLASSES": ["app01.utils.TokenAuth",]# 全局认证 TokenAuth路径
    }

4.权限组件

model
    class User(models.Model):
        name=models.CharField(max_length=32)
        pwd=models.CharField(max_length=32)
        type_choices=((1,"普通用户"),(2,"VIP"),(3,"SVIP"))
        user_type=models.IntegerField(choices=type_choices,default=1)
        
    自定义权限类
    class SVIPPermission(object):
    message="只有超级用户才能访问"#自定义返回信息
    def has_permission(self,request,view):
        username=request.user
        token = request.auth
        #print(username,token)认证组件的返回值为 user.name , token 
        user_type=User.objects.filter(name=username).first().user_type

        if user_type==3:

            return True # 通过权限认证
        else:
            return False
    
    局部权限
    views
    class BookView(APIView):
        authentication_classes = [TokenAuth,]#认证
        permission_classes = [SVIPPermission, ]#权限
    全局权限
    setting.py
    REST_FRAMEWORK = {
        "DEFAULT_AUTHENTICATION_CLASSES": ["app01.utils.TokenAuth",]# 全局认证 TokenAuth路径
        "DEFAULT_PERMISSION_CLASSES": ["app01.utils.SVIPPermission",],#全局权限
    }

5.频率组件

局部频率限制限制

rom rest_framework.throttling import BaseThrottle

    VISIT_RECORD={}
    class VisitThrottle(BaseThrottle):

        def __init__(self):
            self.history=None

        def allow_request(self,request,view):
            remote_addr = request.META.get('REMOTE_ADDR')
            print(remote_addr)
            import time
            ctime=time.time()

            if remote_addr not in VISIT_RECORD:
                VISIT_RECORD[remote_addr]=[ctime,]
                return True

            history=VISIT_RECORD.get(remote_addr)
            self.history=history

            while history and history[-1]<ctime-60:
                history.pop()

            if len(history)<3:
                history.insert(0,ctime)
                return True
            else:
                return False

        def wait(self):
            import time
            ctime=time.time()
            return 60-(ctime-self.history[-1])
    
    
    from app01.service.throttles import *

        class BookViewSet(generics.ListCreateAPIView):
            throttle_classes = [VisitThrottle,]

全局频率限制

频率限制类
    class VisitThrottle(SimpleRateThrottle):
        scope="visit_rate"
        def get_cache_key(self, request, view):
            return self.get_ident(request)
    
    setting.py
    REST_FRAMEWORK={
        "DEFAULT_THROTTLE_CLASSES":["app01.service.throttles.VisitThrottle",]，
        "DEFAULT_THROTTLE_RATES":{
            "visit_rate":"5/m",
        }
    }

6.解析器 

局部解析
    from rest_framework.parsers import JSONParser,FormParser,MultiPartParser,FileUploadParser
    class BookView(APIView):
        #parser_classes = [FormParser,]#解析器(默认JSONParser,FormParser,MultiPartParser)
    
    全局解析
    REST_FRAMEWORK = {
        #定义全局解析
        # 'DEFAULT_PARSER_CLASSES': [ 
        #     'rest_framework.parsers.JSONParser'
        #     'rest_framework.parsers.FormParser'
        #     'rest_framework.parsers.MultiPartParser'
        # ]
    }
    
    仅上传文件
    url
    from django.conf.urls import url, include
    from web.views import TestView

    urlpatterns = [
        url(r'test/(?P<filename>[^/]+)', TestView.as_view(), name='test'),
    ]
    
    views
    from rest_framework.views import APIView
    from rest_framework.response import Response
    from rest_framework.request import Request
    from rest_framework.parsers import FileUploadParser


    class TestView(APIView):
        parser_classes = [FileUploadParser, ]

        def post(self, request, filename, *args, **kwargs):
            print(filename)
            print(request.content_type)

            # 获取请求的值，并使用对应的JSONParser进行处理
            print(request.data)
            # application/x-www-form-urlencoded 或 multipart/form-data时，request.POST中才有值
            print(request.POST)
            print(request.FILES)
            return Response('POST请求，响应内容')

        def put(self, request, *args, **kwargs):
            return Response('PUT请求，响应内容')    

    template
    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Title</title>
    </head>
    <body>
    <form action="http://127.0.0.1:8000/test/f1.numbers" method="post" enctype="multipart/form-data">
        <input type="text" name="user" />
        <input type="file" name="img">

        <input type="submit" value="提交">

    </form>
    </body>
    </html>

7.url路由控制

自定义路由

from django.conf.urls import url, include
    from web.views import s11_render
    urlpatterns = [
        url(r'^test/$', s11_render.TestView.as_view()),
        url(r'^test\.(?P<format>[a-z0-9]+)$', s11_render.TestView.as_view()),
        url(r'^test/(?P<pk>[^/.]+)/$', s11_render.TestView.as_view()),
        url(r'^test/(?P<pk>[^/.]+)\.(?P<format>[a-z0-9]+)$', s11_render.TestView.as_view())
    ]
    
    from rest_framework.views import APIView
    from rest_framework.response import Response
    from .. import models
    class TestView(APIView):
        def get(self, request, *args, **kwargs):
            print(kwargs)
            print(self.renderer_classes)
            return Response('...')

半自动路由

from django.conf.urls import url, include
    from web.views import s10_generic

    urlpatterns = [
        url(r'^test/$', s10_generic.UserViewSet.as_view({'get': 'list', 'post': 'create'})),
        url(r'^test/(?P<pk>\d+)/$', s10_generic.UserViewSet.as_view(
            {'get': 'retrieve', 'put': 'update', 'patch': 'partial_update', 'delete': 'destroy'})),
    ]

    from rest_framework.viewsets import ModelViewSet
    from rest_framework import serializers
    from .. import models

    class UserSerializer(serializers.ModelSerializer):
        class Meta:
            model = models.UserInfo
            fields = "__all__"

    class UserViewSet(ModelViewSet):
        queryset = models.UserInfo.objects.all()
        serializer_class = UserSerializer

全自动路由

from django.conf.urls import url, include
    from rest_framework import routers
    from web.views import s10_generic


    router = routers.DefaultRouter()
    router.register(r'users', s10_generic.UserViewSet)

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

    from rest_framework.viewsets import ModelViewSet
    from rest_framework import serializers
    from .. import models


    class UserSerializer(serializers.ModelSerializer):
        class Meta:
            model = models.UserInfo
            fields = "__all__"


    class UserViewSet(ModelViewSet):
        queryset = models.UserInfo.objects.all()
        serializer_class = UserSerializer

8.分页组件(可在setting全局配置)

根据页码进行分页

from rest_framework.pagination import PageNumberPagination
    class ResultsPagination(PageNumberPagination):
        page_size = 2 #默认每页显示多少条数据
        page_size_query_param = "page_size" #获取URL参数设置的每页显示数据条数
        page_query_param = "page" #获取URL参数中传入的页码
        max_page_size = 1 #最大支持的每页显示的数据条数

    class BookView(APIView):
        def get(self,request):
            book_list=Book.objects.all()
            # 实例化分页对象，获取数据库中的分页数据
            paginator = ResultsPagination()
            page_user_list = paginator.paginate_queryset(book_list,request,self)
            #把实例化得数据传入序列化组件
            bs=BookModelSerializers(page_user_list,many=True,context={'request': request})
            return Response(bs.data)

根据位置和个数进行分页

from rest_framework.pagination import LimiOffsetPagination
    class ResultsPagination(LimitOffsetPagination):
        # 默认每页显示的数据条数
        default_limit = 10
        # URL中传入的显示数据条数的参数
        limit_query_param = 'limit'
        # URL中传入的数据位置的参数
        offset_query_param = 'offset'
        # 最大每页显得条数
        max_limit = None
    
    class BookView(APIView):
        def get(self,request):
            book_list=Book.objects.all()
            # 实例化分页对象，获取数据库中的分页数据
            paginator = ResultsPagination()
            page_user_list = paginator.paginate_queryset(book_list,request,self)
            #把实例化得数据传入序列化组件
            bs=BookModelSerializers(page_user_list,many=True,context={'request': request})
            return Response(bs.data)

9.版本

基于url的get传参方式

REST_FRAMEWORK = {
        'DEFAULT_VERSION': 'v1',            # 默认版本
        'ALLOWED_VERSIONS': ['v1', 'v2'],   # 允许的版本
        'VERSION_PARAM': 'version'          # URL中获取值的key
    }
    
    from django.conf.urls import url, include
    from web.views import TestView
    urlpatterns = [
        url(r'^test/', TestView.as_view(),name='test'),
    ]
    
    #!/usr/bin/env python
    # -*- coding:utf-8 -*-
    from rest_framework.views import APIView
    from rest_framework.response import Response
    from rest_framework.versioning import QueryParameterVersioning
    class TestView(APIView):
        versioning_class = QueryParameterVersioning
        def get(self, request, *args, **kwargs):
            # 获取版本
            print(request.version)
            # 获取版本管理的类
            print(request.versioning_scheme)
            # 反向生成URL
            reverse_url = request.versioning_scheme.reverse('test', request=request)
            print(reverse_url)
            return Response('GET请求，响应内容')
        def post(self, request, *args, **kwargs):
            return Response('POST请求，响应内容')
        def put(self, request, *args, **kwargs):
            return Response('PUT请求，响应内容')

基于url正则方式

urls
    from django.conf.urls import url, include
    from web.views import TestView

    urlpatterns = [
        url(r'^(?P<version>[v1|v2]+)/test/', TestView.as_view(), name='test'),
    ]

    views
    
    from rest_framework.views import APIView
    from rest_framework.response import Response
    from rest_framework.versioning import URLPathVersioning
    class TestView(APIView):
        versioning_class = URLPathVersioning

        def get(self, request, *args, **kwargs):
            # 获取版本
            print(request.version)
            # 获取版本管理的类
            print(request.versioning_scheme)

            # 反向生成URL
            reverse_url = request.versioning_scheme.reverse('test', request=request)
            print(reverse_url)

            return Response('GET请求，响应内容')

        def post(self, request, *args, **kwargs):
            return Response('POST请求，响应内容')

        def put(self, request, *args, **kwargs):
            return Response('PUT请求，响应内容')

    setting
    REST_FRAMEWORK = {
        'DEFAULT_VERSION': 'v1',            # 默认版本
        'ALLOWED_VERSIONS': ['v1', 'v2'],   # 允许的版本
        'VERSION_PARAM': 'version'          # URL中获取值的key
    }

基于 accept 请求头方式

REST_FRAMEWORK = {
        'DEFAULT_VERSION': 'v1',            # 默认版本
        'ALLOWED_VERSIONS': ['v1', 'v2'],   # 允许的版本
        'VERSION_PARAM': 'version'          # URL中获取值的key
    }
    
    from django.conf.urls import url, include
    from web.views import TestView

    urlpatterns = [
        url(r'^test/', TestView.as_view(), name='test'),
    ]

    #!/usr/bin/env python
    # -*- coding:utf-8 -*-
    from rest_framework.views import APIView
    from rest_framework.response import Response
    from rest_framework.versioning import AcceptHeaderVersioning


    class TestView(APIView):
        versioning_class = AcceptHeaderVersioning

        def get(self, request, *args, **kwargs):
            # 获取版本 HTTP_ACCEPT头
            print(request.version)
            # 获取版本管理的类
            print(request.versioning_scheme)
            # 反向生成URL
            reverse_url = request.versioning_scheme.reverse('test', request=request)
            print(reverse_url)

            return Response('GET请求，响应内容')

        def post(self, request, *args, **kwargs):
            return Response('POST请求，响应内容')

        def put(self, request, *args, **kwargs):
            return Response('PUT请求，响应内容') 

全局使用

settings.py
    REST_FRAMEWORK = {
        'DEFAULT_VERSIONING_CLASS':"rest_framework.versioning.URLPathVersioning",
        'DEFAULT_VERSION': 'v1',
        'ALLOWED_VERSIONS': ['v1', 'v2'],
        'VERSION_PARAM': 'version' 
    }
    views
    from rest_framework.views import APIView
    from rest_framework.response import Response
    from rest_framework.versioning import URLPathVersioning
    class TestView(APIView):
        def get(self, request, *args, **kwargs):
            # 获取版本
            print(request.version)
            # 获取版本管理的类
            print(request.versioning_scheme)

            # 反向生成URL
            reverse_url = request.versioning_scheme.reverse('test', request=request)
            print(reverse_url)

            return Response('GET请求，响应内容')

        def post(self, request, *args, **kwargs):
            return Response('POST请求，响应内容')

        def put(self, request, *args, **kwargs):
            return Response('PUT请求，响应内容')