django之rest-framework

django的rest-framework是django很贴心的为我们准备的一个实例化app

https://www.django-rest-framework.org/

安装这个app

pip install djangorestframework

安装好之后需要我们在项目的setting里面注册这个app

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'app01.apps.App01Config',
    "rest_framework",
]

现在我们就可以使用他的功能了,在使用之前我们可以先来看下我们之前是怎么来序列化的,先导入一些测试的数据:

from django.db import models

# Create your models here.


class Book(models.Model):
    title=models.CharField(max_length=32)
    price=models.IntegerField()
    pub_date=models.DateField()
    publish=models.ForeignKey("Publish")
    authors=models.ManyToManyField("Author")
    def __str__(self):
        return self.title

class Publish(models.Model):
    name=models.CharField(max_length=32)
    email=models.EmailField()
    def __str__(self):
        return self.name

class Author(models.Model):
    name=models.CharField(max_length=32)
    age=models.IntegerField()
    def __str__(self):
        return self.name

首先我们看下我们可以使用的第一种方式:

from django.views import View
from app01.models import *
import json


class PublishView(View):

    def get(self,request):
        # 方式一
        # publish_list = list(Publish.objects.all().values("id","name"))
        # 或者也可以这样
        publish_list = Publish.objects.all()
        tem = []
        for obj in publish_list:
            tem.append({
                "id":obj.pk,
                "name":obj.name
            })
        
        

        # return HttpResponse(json.dumps(publish_list))
        return HttpResponse(json.dumps(tem))

结果如下:


[{"id": 1, "name": "\u82f9\u679c\u51fa\u7248\u793e"}, {"id": 2, "name": "\u9999\u8549\u51fa\u7248\u793e"}, {"id": 3, "name": "\u6a58\u5b50\u51fa\u7248\u793e"}]

我们也可以使用下边这种方式:

    def get(self,request):
        

        from django.forms.models import model_to_dict
        tem = []
        for obj in publish_list:
            tem.append(model_to_dict(obj))

      
        return HttpResponse(json.dumps(tem))


结果:

[{"id": 1, "name": "\u82f9\u679c\u51fa\u7248\u793e", "email": "123@qq.com"}, {"id": 2, "name": "\u9999\u8549\u51fa\u7248\u793e", "email": "123@qq.com"}, {"id": 3, "name": "\u6a58\u5b50\u51fa\u7248\u793e", "email": "123@qq.com"}]

现在我们来看下带三种 :

class PublishView(View):

    def get(self,request):
        


        from django.core import serializers
        ret = serializers.serialize("json",publish_list)

        return HttpResponse(ret)

结果:
　　[{"model": "app01.publish", "pk": 1, "fields": {"name": "\u82f9\u679c\u51fa\u7248\u793e", "email": "123@qq.com"}}, {"model": "app01.publish", "pk": 2, "fields": {"name": "\u9999\u8549\u51fa\u7248\u793e", "email": "123@qq.com"}}, {"model": "app01.publish", "pk": 3, "fields": {"name": "\u6a58\u5b50\u51fa\u7248\u793e", "email": "123@qq.com"}}]

我们可以看到第三种是最简单的同时也是结果最多的,接下来是我们的rest-framework,在使用之前我们需要先创建一个类,把我们需要序列化的字段放在我们这个类里边.

from rest_framework import serializers
from rest_framework.views import APIView
from rest_framework.response import Response

class BookSerializers(serializers.Serializer):
    title = serializers.CharField()
    price = serializers.CharField()
    pub_date = serializers.CharField()
    publish = serializers.CharField(source="publish.email")
    # authors = serializers.CharField(source="authors.all")
    authors = serializers.SerializerMethodField()

    def get_authors(self,obj):
        temp = []
        for obj in obj.authors.all():
            temp.append(obj.name)
        return temp

如果是外键关联的我们需要加一个参数source="" 表示用来显示的字段

如果是多对多关联 我们需要用到SerializerMethodField() 这个字段,并且下边用到一个方法做配置   只可以是固定写法 get_加字段名

现在我们就可以使用了

from rest_framework.response import Response

class Bookview(APIView):
    def get(self,request):
        book_list = Book.objects.all()
        bs = BookSerializers(book_list,many=True)
        return Response(bs.data)
    def post(self,request):
        pass

结果:

[
{
"title": "三体",
"price": "255",
"pub_date": null,
"publish": "123@qq.com",
"authors": [
"鲁迅"
]
}
]

这里还是有点麻烦的 , 也和modelfrom一样,人家组件也给我们准备了一个差不多的类:

class BookmodelSerializers(serializers.ModelSerializer):
    class Meta:
        model = Book
        fields = "__all__"

    publish = serializers.CharField (source="publish.name")
    authors = serializers.SerializerMethodField ()
    def get_authors(self, obj):
        temp = []
        for obj in obj.authors.all():
            temp.append(obj.name)
        return temp

如上  我们在这个类里也是可以自己配置字段的显示名称的

post

对于post请求,我们我们也可以用很少的代码来实现复杂的需求:

class Bookview(APIView):
    def get(self,request):
        book_list = Book.objects.all()
        bs = BookmodelSerializers(book_list,many=True)
        return Response(bs.data)
    def post(self,request):
        bs = BookmodelSerializers(data=request.data)
        if bs.is_valid():
            bs.save()
            return Response(bs.data)
        else:
            return Response(bs.errors)

组件自带了校验的功能 , 如上 我们只需要把校验好的数据直接save提交创建就好了 , 没有通过校验的,我们也可以通过error方法取到,给用户返回

这里需要注意一点就是 , 如果我们有自定义显示的字段   save封装的create方法是没有办法帮我们创建的  这时候就需要我们自己重写一个creat方法了

class BookmodelSerializers(serializers.ModelSerializer):
    class Meta:
        model = Book
        fields = "__all__"

    publish = serializers.CharField (source="publish.pk")
    # authors = serializers.SerializerMethodField ()
    # def get_authors(self, obj):
    #     temp = []
    #     for obj in obj.authors.all():
    #         temp.append(obj.name)
    #     return temp

    def create(self, validated_data):

        print("validated_data",validated_data)
        book=Book.objects.create(title=validated_data["title"],price=validated_data["price"],pub_date=validated_data["pub_date"],publish_id=validated_data["publish"]["pk"])
        book.authors.add(*validated_data["authors"])

        return book

写出来的就是上边这个结果了  这里为了能创建成功 上边的字段做一些改动  ,  之前的实在不会搞了.

上边的这些我们处理了多条数据 , 如果有用到单条数据我们需要重新创建一个类

# 单条数据

class BookDetailView(APIView):

    def get(self,request,id):
        book = Book.objects.filter(pk=id).first()
        bs = BookmodelSerializers(book)
        return Response(bs.data)

    def put(self,request,id):
        book = Book.objects.filter(pk=id).first()
        bs = BookmodelSerializers(book,data=request.data)
        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()

 

超链接

有时候我们会有需求,在点开book的时候 我们希望能看到publish的连接  现在我们可以做如下的配置

1 给每一个url配置一个name,并且给我们需要展示连接的url正则加一个名字,

　　这里需要注意一点 我们给 参数 起了名字 我们后续需要用到的形参 也是需要叫这个名字的 

urlpatterns = [
    url(r'^admin/', admin.site.urls),
    url(r'^publish/$', views.PublishView.as_view(),name="publish"),
    url(r'^book/$', views.Bookview.as_view(),name="book"),
    url(r'^book/(\d+)/', views.BookDetailView.as_view(),name="book_detail"),
    url(r'^publish/(?P<pk>\d+)/', views.PublishDetailView.as_view(),name="publish_detail"),
]

2 在book重新配置他的publish关联字段:

class BookmodelSerializers(serializers.ModelSerializer):
    class Meta:
        model = Book
        fields = "__all__"

    publish = serializers.HyperlinkedIdentityField (
        view_name='publish_detail',
        lookup_field="publish_id",
        lookup_url_kwarg="pk")

上边分别获取了 url的名字 , 正则匹配到的值, 以及(\d+)的名字

然后我们就可以发送get请求看到我们需要的连接了:

这里会有一个报错提示我们加上

context={'request': request}

我们只需要在用到实例化的时候加上就可以可以了,下边的put请求也会收到这个报错,我们就一块加上

class BookDetailView(APIView):

    def get(self,request,id):
        book = Book.objects.filter(pk=id).first()
        bs = BookmodelSerializers(book,context={'request': request})
        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})
        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()

现在我们就可以看到这个结果了:

{
    "id": 1,
    "publish": "http://127.0.0.1:8000/publish/1/",
    "title": "三体",
    "price": 255,
    "pub_date": null,
    "authors": [
        1
    ]
}

 一般我们对于增删该查返回值有以下这个规范:

   这个一般是所有文件的get和post,写到一个类里面
          /books/     -----get               books      -----  返回当前所有数据
         /books/     -----post               books      -----  返回提交数据 
    这个一般是面向单个数据  , 我们写到另外一个类里面     
         /books/(\d+)-----get            bookdetail -----  返回当前查看的单条数据 
         /books/(\d+)-----put            bookdetail -----  返回更新数据 
         /books/(\d+)-----delete         bookdetail -----  返回空

 

mixin类编写视图

上边我们写好的视图是长成这样子的:

from django.shortcuts import render,HttpResponse

# Create your views here.

from django.views import View
from app01.models import *
import json
from rest_framework import serializers
from rest_framework.views import APIView
from rest_framework.response import Response
from app01.serializers import *






class PublishView(APIView):

    def get(self,request):
        # 方式一
        # publish_list = list(Publish.objects.all().values("id","name"))
        # 或者也可以这样
        publish_list = Publish.objects.all()
        # tem = []
        # for obj in publish_list:
        #     tem.append({
        #         "id":obj.pk,
        #         "name":obj.name
        #     })

        # from django.forms.models import model_to_dict
        # tem = []
        # for obj in publish_list:
        #     tem.append(model_to_dict(obj))

        from django.core import serializers
        ret = serializers.serialize("json",publish_list)

        # return HttpResponse(json.dumps(publish_list))
        return HttpResponse(ret)


    def post(self,request):

        return HttpResponse(666)



class Bookview(APIView):
    def get(self,request):
        book_list = Book.objects.all()
        bs = BookmodelSerializers(book_list,many=True,context={'request': request})
        return Response(bs.data)
    def post(self,request):
        bs = BookmodelSerializers(data=request.data)
        if bs.is_valid():
            bs.save()
            return Response(bs.data)
        else:
            return Response(bs.errors)

# 单条数据

class BookDetailView(APIView):

    def get(self,request,id):
        book = Book.objects.filter(pk=id).first()
        bs = BookmodelSerializers(book,context={'request': request})
        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})
        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()




class PublishDetailView(APIView):
    def get(self, request, pk):
        publish = Publish.objects.filter (pk=pk).first ()
        ps = PublishSerializers (publish)
        return Response (ps.data)

    def put(self, request, pk):
        publish = Publish.objects.filter (pk=pk).first ()
        ps = PublishSerializers (publish, data=request.data)
        if ps.is_valid ():
            ps.save ()
            return Response (ps.data)
        else:
            return Response (ps.errors)

    def delete(self, request, pk):
        Publish.objects.filter (pk=pk).delete ()
        return Response ()

我们可以看到有很多重复的代码 , 这时候我们可以用到mixin类 , 很多逻辑帮我们进行了封装:

from rest_framework import mixins,generics



class AuthorView(mixins.ListModelMixin,mixins.CreateModelMixin,generics.GenericAPIView):
    queryset = Author.objects.all ()
    serializer_class = AuthorSerializers
    def get(self, request, *args, **kwargs):
        return self.list(self, request, *args, **kwargs)
    def post(self, request, *args, **kwargs):
        return self.create(self, request, *args, **kwargs)

上边的代码中 , 我们继承了三个类 

mixins.ListModelMixin,   mixins.CreateModelMixin,  

里边帮我们封装了list 和create方法     

generics.GenericAPIView 帮我们重写了APIView 

queryset = Author.objects.all ()
serializer_class = AuthorSerializers   这两句是固定的写法 , 需要把我们的表名和配置类做一个赋值

我们只需要继承这三个类直接调用就可以了,同样可以看到我们需要的结果

如果是对单个的操作  我们只要继承这几个类就可以了

class AuthorDetailView(
                    mixins.UpdateModelMixin,
                    mixins.DestroyModelMixin,
                    mixins.RetrieveModelMixin,
                    generics.GenericAPIView
                ):
    queryset = Author.objects.all ()
    serializer_class = AuthorSerializers

    def get(self, request, *args, **kwargs):
        return self.retrieve(self, request, *args, **kwargs)

    def put(self, request, *args, **kwargs):
        return self.update(self, request, *args, **kwargs)

    def delete(self, request, *args, **kwargs):
        return self.destroy(self, request, *args, **kwargs)

这里需要注意一点 我们在填写url的时候参数一定要有一个名字叫pk不然会报错:

url(r'^author/(?P<pk>\d+)/', views.AuthorDetailView.as_view(),name="author_detail"),

通过使用mixin类，我们使用更少的代码重写了这些视图，但我们还可以再进一步。REST框架又为我们做了一层封装 帮我们把上边的几个类封装到了一个类里边 , 我们在使用的时候只需要这样写就可以了:

class AuthorView(generics.ListCreateAPIView):
    queryset = Author.objects.all ()
    serializer_class = AuthorSerializers

class AuthorDetailView(generics.RetrieveUpdateDestroyAPIView):
    queryset = Author.objects.all ()
    serializer_class = AuthorSerializers

现在已经很简洁了       REST框架在此基础上又帮我们把两个类合并成了一个类 , 我们只需要把我们的需要用到的方法通过as_view()方法传给我们继承的类就可以了 写法:

from rest_framework import viewsets
class AuthorView(viewsets.ModelViewSet):
    queryset = Author.objects.all ()
    serializer_class = AuthorSerializers



url:

url(r'^author/$', views.AuthorView.as_view({
                                            "get":"list",
                                            "post":"create"
                                        }),name="author"),
    url(r'^author/(?P<pk>\d+)/', views.AuthorView.as_view({
                                            "get":"retrieve",
                                            "put":"update",
                                            "delete":"destroy"
                                        }),name="author_detail"),
]

认证组件

我们使用认证组件需要配置我们的认证类: 这里我们需要注意 我们的类 里边的方法和返回值是人家提前写好的 这里我们只可以是一个固定的写法

from rest_framework import exceptions

from rest_framework.authentication import BaseAuthentication


from .models import *
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

在我们需要认证的视图当中要有如下写法:

from rest_framework import viewsets
from app01.utils import TokenAuth
class AuthorView(viewsets.ModelViewSet):
    authentication_classes = [TokenAuth, ]
    queryset = Author.objects.all ()
    serializer_class = AuthorSerializers

我们也可以配置全局的认证:

REST_FRAMEWORK = {
    "DEFAULT_AUTHENTICATION_CLASSES": ["app01.utils.TokenAuth",]
}

权限组件

权限组件这里和认证组件是很像的 写法如下:

我们配置一个权限类:

class Svip_permission(object):
    def has_permission(self,request,view):
        username = request.user
        user_type = User.objects.filter(name=username).first().user_type
        if user_type == 3:
            return True
        else:
            return False
  
和上边一样在我们视图里边添加我们的配置类:
permission_classes = [Svip_permission]

这里我们也是可以配置全局的   如果用不到全局 我们只需要在用到的地方加上这个配置类就可以了    也可以在有了全局配置之后我们给

permission_classes   赋值一个空的列表

'DEFAULT_PERMISSION_CLASSES': (
        'rest_framework.permissions.AllowAny',
    ),



我们把我们写好的类放在这个里边就可以了

频率组件

和上边用了同样的玩法 如下:

class VisitRateThrottle(object):
    def allow_request(self,request,view):
        pass



throttle_classes = [VisitRateThrottle]



 'DEFAULT_THROTTLE_CLASSES': (),

解析器

REST框架比django多配置了Json的解析器  下边是配置和使用:

from rest_framework.parsers import JSONParser



class JSONParser(BaseParser):
    """
    Parses JSON-serialized data.
    """
    media_type = 'application/json'
    renderer_class = renderers.JSONRenderer
    strict = api_settings.STRICT_JSON

    def parse(self, stream, media_type=None, parser_context=None):
        """
        Parses the incoming bytestream as JSON and returns the resulting data.
        """
        parser_context = parser_context or {}
        encoding = parser_context.get('encoding', settings.DEFAULT_CHARSET)

        try:
            decoded_stream = codecs.getreader(encoding)(stream)
            parse_constant = json.strict_constant if self.strict else None
            return json.load(decoded_stream, parse_constant=parse_constant)
        except ValueError as exc:
            raise ParseError('JSON parse error - %s' % six.text_type(exc))


class FormParser(BaseParser):
    """
    Parser for form data.
    """
    media_type = 'application/x-www-form-urlencoded'

    def parse(self, stream, media_type=None, parser_context=None):
        """
        Parses the incoming bytestream as a URL encoded form,
        and returns the resulting QueryDict.
        """
        parser_context = parser_context or {}
        encoding = parser_context.get('encoding', settings.DEFAULT_CHARSET)
        data = QueryDict(stream.read(), encoding=encoding)
        return data


class MultiPartParser(BaseParser):
    """
    Parser for multipart form data, which may include file data.
    """
    media_type = 'multipart/form-data'

    def parse(self, stream, media_type=None, parser_context=None):
        """
        Parses the incoming bytestream as a multipart encoded form,
        and returns a DataAndFiles object.

        `.data` will be a `QueryDict` containing all the form parameters.
        `.files` will be a `QueryDict` containing all the form files.
        """
        parser_context = parser_context or {}
        request = parser_context['request']
        encoding = parser_context.get('encoding', settings.DEFAULT_CHARSET)
        meta = request.META.copy()
        meta['CONTENT_TYPE'] = media_type
        upload_handlers = request.upload_handlers

        try:
            parser = DjangoMultiPartParser(meta, stream, upload_handlers, encoding)
            data, files = parser.parse()
            return DataAndFiles(data, files)
        except MultiPartParserError as exc:
            raise ParseError('Multipart form parse error - %s' % six.text_type(exc))


class FileUploadParser(BaseParser):
    """
    Parser for file upload data.
    """
    media_type = '*/*'
    errors = {
        'unhandled': 'FileUpload parse error - none of upload handlers can handle the stream',
        'no_filename': 'Missing filename. Request should include a Content-Disposition header with a filename parameter.',
    }

    def parse(self, stream, media_type=None, parser_context=None):
        """
        Treats the incoming bytestream as a raw file upload and returns
        a `DataAndFiles` object.

        `.data` will be None (we expect request body to be a file content).
        `.files` will be a `QueryDict` containing one 'file' element.
        """
        parser_context = parser_context or {}
        request = parser_context['request']
        encoding = parser_context.get('encoding', settings.DEFAULT_CHARSET)
        meta = request.META
        upload_handlers = request.upload_handlers
        filename = self.get_filename(stream, media_type, parser_context)

        if not filename:
            raise ParseError(self.errors['no_filename'])

        # Note that this code is extracted from Django's handling of
        # file uploads in MultiPartParser.
        content_type = meta.get('HTTP_CONTENT_TYPE',
                                meta.get('CONTENT_TYPE', ''))
        try:
            content_length = int(meta.get('HTTP_CONTENT_LENGTH',
                                          meta.get('CONTENT_LENGTH', 0)))
        except (ValueError, TypeError):
            content_length = None

        # See if the handler will want to take care of the parsing.
        for handler in upload_handlers:
            result = handler.handle_raw_input(stream,
                                              meta,
                                              content_length,
                                              None,
                                              encoding)
            if result is not None:
                return DataAndFiles({}, {'file': result[1]})

        # This is the standard case.
        possible_sizes = [x.chunk_size for x in upload_handlers if x.chunk_size]
        chunk_size = min([2 ** 31 - 4] + possible_sizes)
        chunks = ChunkIter(stream, chunk_size)
        counters = [0] * len(upload_handlers)

        for index, handler in enumerate(upload_handlers):
            try:
                handler.new_file(None, filename, content_type,
                                 content_length, encoding)
            except StopFutureHandlers:
                upload_handlers = upload_handlers[:index + 1]
                break

        for chunk in chunks:
            for index, handler in enumerate(upload_handlers):
                chunk_length = len(chunk)
                chunk = handler.receive_data_chunk(chunk, counters[index])
                counters[index] += chunk_length
                if chunk is None:
                    break

        for index, handler in enumerate(upload_handlers):
            file_obj = handler.file_complete(counters[index])
            if file_obj is not None:
                return DataAndFiles({}, {'file': file_obj})

        raise ParseError(self.errors['unhandled'])

    def get_filename(self, stream, media_type, parser_context):
        """
        Detects the uploaded file name. First searches a 'filename' url kwarg.
        Then tries to parse Content-Disposition header.
        """
        try:
            return parser_context['kwargs']['filename']
        except KeyError:
            pass

        try:
            meta = parser_context['request'].META
            disposition = parse_header(meta['HTTP_CONTENT_DISPOSITION'].encode('utf-8'))
            filename_parm = disposition[1]
            if 'filename*' in filename_parm:
                return self.get_encoded_filename(filename_parm)
            return force_text(filename_parm['filename'])
        except (AttributeError, KeyError, ValueError):
            pass

    def get_encoded_filename(self, filename_parm):
        """
        Handle encoded filenames per RFC6266. See also:
        https://tools.ietf.org/html/rfc2231#section-4
        """
        encoded_filename = force_text(filename_parm['filename*'])
        try:
            charset, lang, filename = encoded_filename.split('\'', 2)
            filename = urlparse.unquote(filename)
        except (ValueError, LookupError):
            filename = force_text(filename_parm['filename'])
        return filename

我们在视图中和全局的使用:

parser_classes = []



全局:
 'DEFAULT_PARSER_CLASSES': (
        'rest_framework.parsers.JSONParser',
        'rest_framework.parsers.FormParser',
        'rest_framework.parsers.MultiPartParser'
    ),

url控制

我们的url写法有很多复用 ,可以用如下方法进行封装:

from django.urls import include, path
from rest_framework import routers
from tutorial.quickstart import views

router = routers.DefaultRouter()
router.register(r'users', views.UserViewSet)
router.register(r'groups', views.GroupViewSet)

# Wire up our API using automatic URL routing.
# Additionally, we include login URLs for the browsable API.
urlpatterns = [
    path('', include(router.urls)),
    path('api-auth/', include('rest_framework.urls', namespace='rest_framework'))
]

分页和偏移分页

from rest_framework.pagination import PageNumberPagination,LimitOffsetPagination

class PNPagination(PageNumberPagination):
        page_size = 1
        page_query_param = 'page'
        page_size_query_param = "size"
        max_page_size = 5

class BookViewSet(viewsets.ModelViewSet):

    queryset = Book.objects.all()
    serializer_class = BookSerializers
    def list(self,request,*args,**kwargs):

        book_list=Book.objects.all()
        pp=LimitOffsetPagination()
        pager_books=pp.paginate_queryset(queryset=book_list,request=request,view=self)
        print(pager_books)
        bs=BookSerializers(pager_books,many=True)

        #return Response(bs.data)
        return pp.get_paginated_response(bs.data)

偏移分页

from rest_framework.pagination import LimitOffsetPagination

 版本组件:

1. 添加配置
                REST_FRAMEWORK = {
                    
                    .... 
                    
                    'DEFAULT_VERSIONING_CLASS':'rest_framework.versioning.URLPathVersioning',
                    'ALLOWED_VERSIONS':['v1','v2'], # 允许的版本
                    'VERSION_PARAM':'version', # 参数
                    'DEFAULT_VERSION':'v1', # 默认版本
                    ....
                }

            2. 设置路由 
                
                s9luffycity/urls.py
                    urlpatterns = [
                        #url(r'^admin/', admin.site.urls),
                        url(r'^api/(?P<version>\w+)/', include('api.urls')),
                    ]
                
                api/urls.py 
                    urlpatterns = [
                        url(r'^course/$', course.CourseView.as_view()),
                    ]
            
            3. 获取版本 
                request.version 获取版本  
            

 表关联:

class CourseDtailRest(serializers.ModelSerializer):
    class Meta:
        model = Course_detail
        fields = "__all__"
        # 取出关联的表  一般不推荐使用
        depth = 1