django restfulwork 源码剖析

概要:

　　1.restful 规范(建议);

　　2. django rest framework框架

内容回顾:

　　1.开发模式;

　　　　- 普通开发模式(前后端放在一起写)

　　　　- 前后端分离

　　　　　　好处: 后端一套,前端使用app，pc等；

　　2. 后端开发

　　　　为前端提供URL(API的开发)

　　　　注:永远返回Httpresponse

　　3. django Fbv 和Cbv

 

一、Django CBV和FBV

在视图中,cbv支持四中method，如下:

from django.views import View
class StudentView(View):

    def get(self,request):
        return HttpResponse('GET')

    def post(self,request):
        return HttpResponse('POST')

    def put(self,request):
        return HttpResponse('POST')

    def delete(self,request):
        return HttpResponse('DELETE')

　　

那么url必须这么写:

from app01 import views
urlpatterns = [
    url(r'^students/$', views.StudentView.as_view()),
]

使用postman进行测试:

查看源码预备知识:封装

#!/usr/bin/env python
# -*- coding: utf-8 -*-

class Request(object):

    def __init__(self, obj):
        self.obj = obj

    @property
    def user(self):
        return self.obj.authticate()

class Auth(object):

    def __init__(self, name, age):
        self.name = name
        self.age = age

    def authticate(self):
        return self.name

class APIView(object):

    def dispatch(self):
        self.f2()

    def f2(self):
        a = Auth('charles', 18)
        req = Request(a)
        print(req.user)

obj = APIView()
obj.dispatch()

　　

CBV实现原理: 在View类中有一个dispatch方法，在每个请求到达之后，会先执行，获取请求的method，然后通过反射，执行子类中对应的方法;

from django.views import View
class StudentView(View):

    def dispatch(self, request, *args, **kwargs):
        # return HttpResponse('dispatch')
        func = getattr(self,request.method.lower())
        ret = func(request, *args, **kwargs)
        return ret

    def get(self,request):
        return HttpResponse('GET')

    def post(self,request):
        return HttpResponse('POST')

    def put(self,request):
        return HttpResponse('POST')

    def delete(self,request):
        return HttpResponse('DELETE')

　　

由上面的例子可以看到，dispatch方法是所有使用CBV的视图必须使用到的方法，为了避免每一个类都实现这个方法，可以通过类的继承，来避免代码的重复:

在下面的例子中，基类MyBaseView实现了一个dispatch方法，子类StudentView实现了继承了MyBaseView和View两个类，在实例化StudentView，并执行其方法的时候，会先在StudentView中寻找dispatch方法，如果没有，会去MyBaseView中去寻找，MyBaseView没有父类，所以会看是self是谁，然后从self的另外一个父类View中去寻找; 顺序是StudentView-->MyBaseView-->View

from django.views import View

class MyBaseView(object):
    def dispatch(self,request, *args, **kwargs):
        print('before')
        ret = super(MyBaseView, self).dispatch(request, *args, **kwargs)
        print('after')
        return ret

class StudentView(MyBaseView,View):

    def get(self,request,*args, **kwargs):
        return HttpResponse('GET')

    def post(self,request,*args, **kwargs):
        return HttpResponse('POST')

    def put(self,request,*args, **kwargs):
        return HttpResponse('POST')

    def delete(self,request,*args, **kwargs):
        return HttpResponse('DELETE')

　　

二、Django中间件

1. 中间件执行顺序(中间件最多可以实现5个方法)

　　正常顺序:  执行所有process_request-->路由匹配-->执行所有process_view-->执行视图函数-->process_response

如果有报错: 执行所有process_request-->路由匹配-->执行所有process_view-->执行视图函数-->process_response

如果视图函数有render:  执行所有process_request-->路由匹配-->执行所有process_view-->执行视图函数-->process_response/process_render_template;

2. 使用中间件做过什么?

- 权限

　　- 用户登录验证

　　- django csrf token

　　那么用户的csrf token是如何实现的?

　　　　 FBV:在django中,csrf token检测是在process_view方法中实现的，会检查视图是否使用@csrf_exempt,然后去请求体或者cookie中获取token;

　　　　　　 如果不使用中间件做csrf token认证,那么可以加@csrf_protect,对指定的实视图做验证;

　　　　 CBV: 有两种实现方法csrf_exempt

from django.views.decorators.csrf import csrf_exempt
from django.utils.decorators import method_decorator

class StudentView(View):

    @method_decorator(csrf_exempt)
    def dispatch(self, request, *args, **kwargs):
        return super(StudentView,self).dispatch(request, *args, **kwargs)

    def get(self,request,*args, **kwargs):
        return HttpResponse('GET')

    def post(self,request,*args, **kwargs):
        return HttpResponse('POST')

    def put(self,request,*args, **kwargs):
        return HttpResponse('POST')

    def delete(self,request,*args, **kwargs):
        return HttpResponse('DELETE')

from django.views.decorators.csrf import csrf_exempt
from django.utils.decorators import method_decorator

@method_decorator(csrf_exempt, name='dispatch')
class StudentView(View):
    def get(self,request,*args, **kwargs):
        return HttpResponse('GET')

    def post(self,request,*args, **kwargs):
        return HttpResponse('POST')

    def put(self,request,*args, **kwargs):
        return HttpResponse('POST')

　　

三、restful 规范

1.根据method 不同，做不同的操作

url(r'^order/$', views.order),

def order(request):
    if request.method == 'GET':
        return HttpResponse('获取订单')
    elif request.method == 'POST':
        return HttpResponse('创建订单')
    elif request.method == 'PUT':
        return HttpResponse('更新订单')
    elif request.method == 'DELETE':
        return HttpResponse('删除订单')

参考:https://www.cnblogs.com/wupeiqi/articles/7805382.html

四、restframework

使用自定义的类，实现API 认证; 具体看源码，和CBV 执行流程类似;

from rest_framework.views import APIView
from rest_framework.request import Request
from rest_framework import exceptions
class MyAuthenticate(object):

    def authenticate(self,request):
        token = request._request.GET.get('token')
        if not token:
            raise exceptions.AuthenticationFailed('用户认证失败')

    def authenticate_header(self, val):
        pass

class DogView(APIView):
    authentication_classes = [MyAuthenticate, ]

    def get(self,request,*args, **kwargs):
        ret = {
            'code': 1000,
            'msg': 'xxx'
        }
        return HttpResponse(json.dumps(ret),status=201)

    def post(self,request,*args, **kwargs):
        return HttpResponse('POST')

    def put(self,request,*args, **kwargs):
        return HttpResponse('POST')

    def delete(self,request,*args, **kwargs):
        return HttpResponse('DELETE')　　

需要掌握的内容:

1.中间件

2.CBV

3.csrf

4.规范

5.djangorestframework

- 如何验证(基于数据库实现用户认证)

-源码流程(面向对象回顾流程)

五、restframework之登录

问题: 有些API用户登录之后才可以访问，有些不需要用户登录;

先创建两张表

class UserInfo(models.Model):   # 用户表，存储用户信息
    user_type_choices = (
        (1,'普通用户'),
        (2,'VIP'),
        (3,'SVIP'),
    )
    user_type = models.IntegerField(choices=user_type_choices)
    username = models.CharField(max_length=32, unique=True)
    password = models.CharField(max_length=64)

class UserToken(models.Model):    # 存储用户登录成功之后的token
    user = models.OneToOneField(to='UserInfo')
    token = models.CharField(max_length=64)

编写API

url(r'^api/v1/auth/$', views.AuthView.as_view())

from django.http import JsonResponse

# Create your views here.

from rest_framework.views import APIView
from api import models

def md5(user):
    import hashlib
    import time

    ctime = str(time.time())
    m = hashlib.md5(bytes(user, encoding='utf-8'))
    m.update(bytes(ctime, encoding='utf-8'))
    return m.hexdigest()

class AuthView(APIView):
    """
     用于用户登录认证
    """

    def post(self, request, *args, **kwargs):
        ret = {'code': 10000, 'msg': None }
        try:
            user = request._request.POST.get('username')
            pwd = request._request.POST.get('password')
            obj = models.UserInfo.objects.filter(username=user,password=pwd).first()
            if not obj:
                ret['code'] = 1001
                ret['msg'] = '用户名或密码错误'
            # 为登录用户创建token
            token = md5(user)
            # 用户token存在就更新，不存在就创建
            models.UserToken.objects.update_or_create(user=obj, defaults={'token': token})
            ret['token'] = token    # 将token返回给用户
        except Exception as e:
            ret['code'] = 1002
            ret['msg'] = '请求异常'
        return JsonResponse(ret)

使用postman发送请求进行验证

六、 rest framework之基于token实现基本用户认证

上面的例子是用户通过访问登录认证的API，获取返回的token，并将token存储到token表中;

用户拿到这个token之后，就可以访问其他的API了;

from rest_framework.views import APIView
from rest_framework.views import exceptions
from rest_framework.authentication import BaseAuthentication
from api import models

ORDER_DICT = {
    1: {
        'name': 'charles',
        'age': 18,
        'gender': '男',
        'content': '....'
    },
    2: {
        'name': '男',
        'age': 19,
        'gender': '男',
        'content': '......'
    },
}

class Authtication(object):

    def authenticate(self, request):
        token = request._request.GET.get('token')
        token_obj = models.UserToken.objects.filter(token=token).first()
        if not token_obj:
            raise exceptions.AuthenticationFailed('用户认证失败')
        # 在restframework内部会将整个两个字段赋值给request，以供后续继续使用
        return (token_obj.user, token_obj)

    def authenticate_header(self, request):
        pass

class OrderView(APIView):
    """
    订单相关业务
    """
    authentication_classes = [Authtication, ]   # 在访问API的时候，先走这个用户认证的类

    def get(self, request, *args, **kwargs):
        ret = {'code': 1000, 'msg': None, 'data': None}
        # request.user --> token_obj.user
        # request.auth --> token_obj
        try:
            ret['data'] = ORDER_DICT
        except Exception as e:
            pass
        return JsonResponse(ret)

七、rest framework之认证基本流程源码分析

1、请求进来之后，会先执行dispatch()方法;

class OrderView(APIView):
    """
    订单相关业务
    """
    authentication_classes = [Authtication, ]

    def get(self, request, *args, **kwargs):
        self.dispatch()      # 使用pycharm进入dispatch方法,查看源码

2、先对request进行封装

self.args = args
        self.kwargs = kwargs
        request = self.initialize_request(request, *args, **kwargs)   # 对request进行封装，点击继续查看该方法

    def initialize_request(self, request, *args, **kwargs):
        """
        Returns the initial request object.
        """
        parser_context = self.get_parser_context(request)

        return Request(
            request,
            parsers=self.get_parsers(),
            authenticators=self.get_authenticators(),    # 执行这个方法会先在本子类中找，显然，子类中是有这个方法的，继续点击查看这个方法；[]
            negotiator=self.get_content_negotiator(),
            parser_context=parser_context
        )

    def get_authenticators(self):
        """
        Instantiates and returns the list of authenticators that this view can use.
        """
        return [auth() for auth in self.authentication_classes]   # 通过列表生成式，执行self.authentication_classes方法，因为子类中没有这个方法，
                                                                   那么会执行父类中的这个方法;  点击继续查看;

    authentication_classes = api_settings.DEFAULT_AUTHENTICATION_CLASSES   # 这个是存在于父类中的;  我们可以在自己的实例化的子类中使用自定义的类，替代这个类; 默认升是

BaseAuthentication

3、认证

self.initial(request, *args, **kwargs)    # 继续点击查看;

self.perform_authentication(request)  # 实现认证;

    def perform_authentication(self, request):
        request.user   # 执行request.user

    @property
    def user(self):
        """
        Returns the user associated with the current request, as authenticated
        by the authentication classes provided to the request.
        """
        if not hasattr(self, '_user'):
            with wrap_attributeerrors():
                # 获取认证对象，进行进一步认证
                self._authenticate()
        return self._user

    def _authenticate(self):
        """
        Attempt to authenticate the request using each authentication instance
        in turn.
        """
        # 循环所有authenticator对象
        for authenticator in self.authenticators:
            try:
                 # 执行authenticate方法
                 # 1.如果authenticate 方法抛出异常,self._not_authenticated执行
                 # 2. 没有抛出异常,有返回值,必须是元祖:(request.user, request.auth)
                 # 3. 返回None，我不管，下一个认证进行处理;
                 # 4.如果都返回None，执行self._not_authenticated(),返回(AnonymousUser, None)
                user_auth_tuple = authenticator.authenticate(self)
            except exceptions.APIException:
                self._not_authenticated()
                raise

            if user_auth_tuple is not None:
                self._authenticator = authenticator
                # request.user和request.auth
                self.user, self.auth = user_auth_tuple
                return

    def _not_authenticated(self):
        """
        Set authenticator, user & authtoken representing an unauthenticated request.

        Defaults are None, AnonymousUser & None.
        """
        self._authenticator = None

        if api_settings.UNAUTHENTICATED_USER:     # AnonymousUser 匿名用户
            self.user = api_settings.UNAUTHENTICATED_USER()
        else:
            self.user = None

        if api_settings.UNAUTHENTICATED_TOKEN:
            self.auth = api_settings.UNAUTHENTICATED_TOKEN()    # None
        else:
            self.auth = None

简要流程图如下:

八、rest framework之匿名用户配置

1.认证类的全局配置(全局使用)

authentication_classes = api_settings.DEFAULT_AUTHENTICATION_CLASSES  # 认证类的默认配置

api_settings = APISettings(None, DEFAULTS, IMPORT_STRINGS)

def reload_api_settings(*args, **kwargs):
    setting = kwargs['setting']
    if setting == 'REST_FRAMEWORK':    # 获取settings的REST_FRAMEWORK 的配置项
        api_settings.reload()

在settings中定义 REST_FRAMEWORK 配置

REST_FRAMEWORK  =  {
    'DEFAULT_AUTHENTICATION_CLASSES': ['api.utils.auth.FirstAuthtication', 'api.utils.auth.Authtication']
}

# 将认证的类，放入到上面配置的路径里面

# 视图函数中不包含上述的认证的类,并且要将登陆的API的authentication_classes设为空;
class AuthView(APIView):
    authentication_classes = []
    def post(self, request, *args, **kwargs):
            pass

class OrderView(APIView):
    """
    订单相关业务
    """

    def get(self, request, *args, **kwargs):
        ret = {'code': 1000, 'msg': None, 'data': None}
        # request.user --> token_obj.user
        # request.auth --> token_obj
        try:
            ret['data'] = ORDER_DICT
        except Exception as e:
            pass
        return JsonResponse(ret)

2、在用户没有登录(匿名用户的时候)

    def _not_authenticated(self):
        """
        Set authenticator, user & authtoken representing an unauthenticated request.

        Defaults are None, AnonymousUser & None.
        """
        self._authenticator = None

        if api_settings.UNAUTHENTICATED_USER:    # 获取settings中的用户默认用户是啥
            self.user = api_settings.UNAUTHENTICATED_USER()
        else:
            self.user = None

        if api_settings.UNAUTHENTICATED_TOKEN:    # 获取settings中的默认token是啥
            self.auth = api_settings.UNAUTHENTICATED_TOKEN()
        else:
            self.auth = None

没有通过认证，默认为匿名用户

class UserInfo(APIView):

    authentication_classes = []
    def get(self,request,  *args, **kwargs):
        ret = {'code': 1000, 'msg': None, 'data': None}
        print(request.user)
        return JsonResponse(ret

# 打印结果
AnonymousUser

# 在settings.py中增加如下配置,未登录时，用户和auth都为None,方面后续判断用户是否登录;
REST_FRAMEWORK  =  {
    'DEFAULT_AUTHENTICATION_CLASSES': ['api.utils.auth.FirstAuthtication', 'api.utils.auth.Authtication'],
    'UNAUTHENTICATED_USER':None,  #request.user
    'UNAUTHENTICATED_TOKEN':None  # request.auth
}

　　

九、rest framework之内置基本认证

1.BaseAuthentication 基类，可以规范自定义的认证的类

from rest_framework.authentication import BaseAuthentication, BasicAuthentication

class FirstAuthtication(BaseAuthentication):

    def authenticate(self, request):
        pass

    def authenticate_header(self, request):
        pass

class Authtication(BaseAuthentication):

    def authenticate(self, request):
        token = request._request.GET.get('token')
        token_obj = models.UserToken.objects.filter(token=token).first()
        if not token_obj:
            raise exceptions.AuthenticationFailed('用户认证失败')
        # 在restframework内部会将整个两个字段赋值给request，以供后续继续使用
        return (token_obj.user, token_obj)

    def authenticate_header(self, request):
        return 'Basic realm="api"'      # api信息加入请求头

2.其他认证   BasicAuthentication

十、rest framework之权限的基本使用

使用方法和自定义认证类非常类似

1.定义权限类

# 定义权限类
class MyPermisson(object):

    def has_permission(self, request, view):
        if request.user.user_type != 3:
            return False
        return True

class MyPermisson1(object):
    def has_permission(self, request, view):
        if request.user.user_type == 3:
            return False
        return True

2. 使用自定义类

class OrderView(APIView):
    """
    订单相关业务
    """
    permission_classes = [MyPermisson, ]

    def get(self, request, *args, **kwargs):
        ret = {'code': 1000, 'msg': None, 'data': None}
        # request.user --> token_obj.user
        # request.auth --> token_obj

十一、 rest framework之权限源码流程

# 查看dispatch中检测权限的方法
 def check_permissions(self, request):
        """
        Check if the request should be permitted.
        Raises an appropriate exception if the request is not permitted.
        """
        for permission in self.get_permissions():
            if not permission.has_permission(request, self):
                self.permission_denied(
                    request, message=getattr(permission, 'message', None)
                )

定义全局的权限检测类,并使用全局配置定义全局权限检测的类

class SVIPPermisson(object):
    message = '必须是SVIP才能访问'
    def has_permission(self, request, view):
        if request.user.user_type != 3:
            return False
        return True

#定义配置
REST_FRAMEWORK  =  {
    'DEFAULT_AUTHENTICATION_CLASSES': ['api.utils.auth.FirstAuthtication', 'api.utils.auth.Authtication'],
    'UNAUTHENTICATED_USER':None,  #request.user
    'UNAUTHENTICATED_TOKEN':None,  # request.auth
    'DEFAULT_PERMISSION_CLASSES':['api.utils.permission.SVIPPermisson']  # request.auth
}

　　

十二、rest framework之权限的内置类

django 内置的权限类在实际生成的环境不建议使用,但是建议继承,可以帮助规范自定义权限类的方法名称;

除了BasePermission之外，还有其他的类:

#实现代码：
from rest_framework.permissions import BasePermission

class SVIPPermisson(BasePermission):
    message = '必须是SVIP才能访问'
    def has_permission(self, request, view):
        if request.user.user_type != 3:
            return False
        return True

class MyPermisson1(BasePermission):
    def has_permission(self, request, view):
        if request.user.user_type == 3:
            return False
        return True

　　

十三、rest framework之访问频率控制基本实现

import time

VISIT_RECODE = {}   # 放在全局变量中，重启之后，就会变空，可以放到缓存中
from rest_framework.throttling import BaseThrottle
class VisitThrottle(object):
    """60秒内只能访问3次"""
    def __init__(self):
        self.histoy = None

    def allow_request(self, request, view):
        # 1.获取用户IP
        remote_addr = request.META.get('REMOTE_ADDR')
        print(remote_addr)
        ctime = time.time()
        if remote_addr not in VISIT_RECODE:
            VISIT_RECODE[remote_addr] = [ctime, ]
            return True
        history = VISIT_RECODE.get(remote_addr)
        self.histoy = history
        while history and history[-1] < ctime -60:    # 如果记录的时间戳超过60s以内，就删除;
            history.pop()

        if len(history) < 3:
            history.insert(0, ctime)
            return True
        # return True  # 表示可以继续访问
        # return  False  # 表示访问频率太高，被限制

    def wait(self):
        """还有等多少秒才能访问 return 10 等10S才能访问"""
        ctime = time.time()
        return 60 - (ctime - self.histoy[-1])

class AuthView(APIView):
    authentication_classes = []
    throttle_classes = [VisitThrottle,]

十四、rest framework之访问频率控制源码流程

源码流程和上述认证与权限源码流程类似,下面使用全局配置类控制访问频率:

将上述代码挪到目录api.utils.thottle.VisitThrottle

REST_FRAMEWORK = {
    'DEFAULT_AUTHENTICATION_CLASSES': ['api.utils.auth.FirstAuthtication', 'api.utils.auth.Authtication'],
    'UNAUTHENTICATED_USER': None,  # request.user
    'UNAUTHENTICATED_TOKEN': None,  # request.auth
    'DEFAULT_PERMISSION_CLASSES':['api.utils.permission.SVIPPermisson'],  # request.auth
    'DEFAULT_THROTTLE_CLASSES': ['api.utils.thottle.VisitThrottle']   # 全局生效
}

十五、rest framework之基于内置类实现访问频率控制

实际上，内置的访问频率类已经实现了上述的方法，可以通过配置来自定义访问频率，VISIT_RECODE 是放置在缓存中的:

from rest_framework.throttling import BaseThrottle, SimpleRateThrottle

class VisitThrottle(SimpleRateThrottle):
    scope = 'visit'

    def get_cache_key(self, request, view):
        return self.get_ident(request)    # 获取用户IP

class UserThrottle(SimpleRateThrottle):
    scope = 'user'

    def get_cache_key(self, request, view):
        return request.user.username

###配置###
REST_FRAMEWORK = {
    'DEFAULT_AUTHENTICATION_CLASSES': ['api.utils.auth.FirstAuthtication', 'api.utils.auth.Authtication'],
    'UNAUTHENTICATED_USER': None,  # request.user
    'UNAUTHENTICATED_TOKEN': None,  # request.auth
    'DEFAULT_PERMISSION_CLASSES':['api.utils.permission.SVIPPermisson'],  # request.auth
    'DEFAULT_THROTTLE_CLASSES': ['api.utils.thottle.VisitThrottle'],   #默认为对匿名用户做限制
    'DEFAULT_THROTTLE_RATES': {
        'visit': '3/m',     # 一分钟访问3次
        'user': '10/m'
    }
}

###同时对登录用户做限制#####
from api.utils.thottle import UserThrottle
class OrderView(APIView):
    """
    订单相关业务
    """
    # permission_classes = [SVIPPermisson, ]
    throttle_classes = [UserThrottle, ]        # 只有用户登录才可以查看订单，使用另外一个访问频率限制类;

十六、版本

1、在url中通过GET传参:

使用自定义的类解析版本

class ParamVersion(object):
    def determine_version(self, request, *args, **kwargs):
        version = request.query_params.get('version')
        return version

class UserView(APIView):
    versioning_class = ParamVersion
    permission_classes = []
    authentication_classes = []
    throttle_classes = []
    def get(self, request, *args, **kwargs):
        print(request.version)
        return HttpResponse('用户列表')

#get请求如下: http://127.0.0.1:8080/api/users/?version=v3

使用内置的类解析版本参数,还可以通过配置定义默认的版本以及允许的版本:

from rest_framework.versioning import QueryParameterVersioning,

class ParamVersion(object):
    def determine_version(self, request, *args, **kwargs):
        version = request.query_params.get('version')
        return version

class UserView(APIView):
    versioning_class = QueryParameterVersioning
    permission_classes = []
    authentication_classes = []
    throttle_classes = []
    def get(self, request, *args, **kwargs):
        print(request.version)
        return HttpResponse('用户列表')

#####settings#####
REST_FRAMEWORK = {
    'DEFAULT_VERSION' : 'v1',   # 默认的版本
    'ALLOWED_VERSIONS' : ['v1', 'v2'],    # 允许请求的版本
    'VERSION_PARAM': 'version',         # 版本的参数的key
}

2、在URL中传参(推荐使用): 版本在使用的时候，无需自定义，使用下面的方式就可以实现了;

urlpatterns = [
    url(r'^(?P<version>[v1|v2]+)/users/$', views.UserView.as_view()),
]

from rest_framework.versioning import QueryParameterVersioning, URLPathVersioning
class UserView(APIView):
    versioning_class = URLPathVersioning   # 除了在这儿设置之外，还可以在配置中设置
    permission_classes = []
    authentication_classes = []
    throttle_classes = []
    def get(self, request, *args, **kwargs):
        print(request.version)
        return HttpResponse('用户列表')

###settings.py######在配置中设置
REST_FRAMEWORK = {
    'DEFAULT_VERSIONING_CLASS': 'rest_framework.versioning.URLPathVersioning',
    'DEFAULT_VERSION' : 'v1',
    'ALLOWED_VERSIONS' : ['v1', 'v2'],
    'VERSION_PARAM': 'version'
}

十七、rest framework框架之版本源码

# 可以在视图中反向解析URL

from django.urls import reverse
class UserView(APIView):
    # versioning_class = ParamVersion
    # versioning_class = URLPathVersioning
    permission_classes = []
    authentication_classes = []
    throttle_classes = []
    def get(self, request, *args, **kwargs):
        # 1.获取版本
        print(request.version)
        # 2.获取处理版本的对象
        print(request.versioning_scheme)

        # 3.反向生成URL(REST FRAMEWORK)
        url1 = request.versioning_scheme.reverse(viewname='uuu', request=request)
        print(url1)

        # 4.反向生成URL
        url2 = reverse(viewname='uuu', kwargs={'version': 2})
        print(url2)
        return HttpResponse('用户列表'）

###打印结果
<rest_framework.versioning.URLPathVersioning object at 0x04335D50>
http://127.0.0.1:8080/api/v2/users/
/api/2/users/

十八、解析器

1.解析器预备知识(post提交的数据，会保存在request.body中,转换为QueryDict才能被request.post获取到)

#点击查看源码,
from  django.core.handlers.wsgi import  WSGIRequest
        elif self.content_type == 'application/x-www-form-urlencoded':
            self._post, self._files = QueryDict(self.body, encoding=self._encoding), MultiValueDict()   #

#如果想通过request.POST获取到post提交的数据，那么必须满足如下两个条件:
django:request.POST/ request.body
			1. 请求头要求：
				Content-Type: application/x-www-form-urlencoded
				PS: 如果请求头中的 Content-Type: application/x-www-form-urlencoded，request.POST中才有值（去request.body中解析数据）。
			2. 数据格式要求：
				  name=charles&age=18&gender=男
# 如果不满足上述条件，那么就必须使用request.body将字节转换为str,然后再做解析:
			如：
				a. form表单提交,请求头和数据都满足上述条件:
					<form method...>
						input...

					</form>

				b. ajax提交
					$.ajax({
						url:...
						type:POST,
						data:{name:alex,age=18} # 内部转化 name=alex&age=18&gender=男
					})

					情况一：   #数据满足，请求头不满足
						$.ajax({
							url:...
							type:POST,
							headers:{'Content-Type':"application/json"}
							data:{name:alex,age=18} # 内部转化 name=alex&age=18&gender=男
						})
						# body有值；POST无
					情况二：# 数据和请求头都不满足
						$.ajax({
							url:...
							type:POST,
							headers:{'Content-Type':"application/json"}
							data:JSON.stringfy({name:alex,age=18}) # {name:alex,age:18...}
						})
						# body有值；POST无
						# json.loads(request.body)

# rest framework 解析器

#JSONParser支持解析请求头为application/json的数据
#FormParser  支持解析请求头为content-type:application/x-www-form-urlencoded的数据

from rest_framework.parsers import JSONParser,FormParser
class ParserView(APIView):
    # parser_classes = [JSONParser,FormParser,]   #查看请求头，自动匹配解析器
    """
    JSONParser:表示只能解析content-type:application/json头
    JSONParser:表示只能解析content-type:application/x-www-form-urlencoded头
    """

    def post(self, request, *args, **kwargs):
        """
        允许用户发送JSON格式数据
            a. content-type: application/json
            b. {'name':'alex',age:18}
        :param request:
        :param args:
        :param kwargs:
        :return:
        """
        """
        1. 获取用户请求
        2. 获取用户请求体
        3. 根据用户请求头 和 parser_classes = [JSONParser,FormParser,] 中支持的请求头进行比较
        4. JSONParser对象去请求体
        5. request.data
        """
        print(request.data)   # 解析后的数据

        return HttpResponse('ParserView')

　　

　通过request.data可以看到解析器的源码，分析得到，解析器可以通过配置定义全局的解析器:

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

使用非默认的解析器使用配置如下:
class ParserView(APIView):
    parser_classes = [JSONParser,FormParser,]   # 自己的视图类中使用的解析器
    """

#除了之外，还有如下的解析器:
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:
        http://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

引申内容如下:

1. http 状态码
2. http请求方法
3. http 请求头

十九、 rest framework框架之序列化

数据库表结构如下:

class UserGroup(models.Model):
    title  = models.CharField(max_length=32)

class UserInfo(models.Model):
    user_type_choices = (
        (1,'普通用户'),
        (2,'VIP'),
        (3,'SVIP'),
    )
    user_type = models.IntegerField(choices=user_type_choices)
    group = models.ForeignKey('UserGroup')

    username = models.CharField(max_length=32, unique=True)
    password = models.CharField(max_length=64)

    roles = models.ManyToManyField('Role')

class UserToken(models.Model):
    user = models.OneToOneField(to='UserInfo')
    token = models.CharField(max_length=64)

class Role(models.Model):
    title  = models.CharField(max_length=32)

　　

1、序列化基本使用

a. django的序列化

如果是django的QuerySet对象，直接使用json.dumps进行处理，是会报错的，使用django的序列化工具不太好用，一版我们使用values/value_list转换为列表之后，再进行序列化:

import json
class RoleView(APIView):
    def get(self, request, *args, **kwargs):
        roles = models.Role.objects.all().values('id', 'title')
        roles = list(roles)
        ret = json.dumps(roles, ensure_ascii=False)   # ensure_ascii=False 表示如果有中文，不是输出字节码，而是中文字符
        return HttpResponse(ret)

　

b.使用rest framework的序列化工具

b1.

from rest_framework import serializers

class RolesSerializer(serializers.Serializer):   # 下面的字段必须是数据库的字段
    id = serializers.IntegerField()
    title = serializers.CharField()

class RoleView(APIView):
    def get(self, request, *args, **kwargs):
        roles = models.Role.objects.all()
        ser = RolesSerializer(instance=roles, many=True)   # 如果QuerySet不是一个对象，使用many=True,如果是一个对象,如.first()/.last(),那么使用many=False
        ret = json.dumps(ser.data, ensure_ascii=False)
        return HttpResponse(ret)　　

b2.

上述序列化的是简单的CharField字典，如果字段是choice/ForeignKey/ManyToMany，那么如何序列化呢?

class UserInfoSerializer(serializers.Serializer):
    xxxx = serializers.CharField(source='user_type')  # 显示choice的id
    ooo = serializers.CharField(source='get_user_type_display')   # 显示choice的value
    username = serializers.CharField()
    password = serializers.CharField()
    gp = serializers.CharField(source='group.title')    # source指定序列化的字段

    # rls = serializers.CharField(source='roles.all')
    rls  = serializers.SerializerMethodField()     # ManyToMany 可以指定方法，由方法返回需要被序列化展示的内容

    def get_rls(self, row):     # 方法名为get_名称(这里是rls)
        roles_obj_list = row.roles.all()
        ret = []
        for item in roles_obj_list:
            ret.append({'id': item.id, 'title': item.title})
        return ret

class UserInfoView(APIView):

    def get(self, request, *args, **kwargs):

        users = models.UserInfo.objects.all()
        ser = UserInfoSerializer(instance=users, many=True)

        ret = json.dumps(ser.data, ensure_ascii=False)
        return HttpResponse(ret)

参考: http://www.cnblogs.com/wupeiqi/articles/7805382.html

b3.

使用rest framework   ModelSerializer也可以使用上述的序列化的功能，但是更省事:

class UserInfoSerializer(serializers.ModelSerializer):
    ooo = serializers.CharField(source='get_user_type_display')
    rls = serializers.SerializerMethodField()

    class Meta:
        model = models.UserInfo
        # fields = "__all__"   # 显示所有字段，但是外键部分只显示ID
        fields = ['id', 'username', 'password', 'ooo', 'rls', 'group']

    def get_rls(self, row):
        roles_obj_list = row.roles.all()
        ret = []
        for item in roles_obj_list:
            ret.append({'id': item.id, 'title': item.title})
        return ret

在序列化的时候，上面的CharField可以使用自定义的类(一般不使用):

class MyField(serializers.CharField):
    pass

class UserInfoSerializer(serializers.ModelSerializer):
    ooo = serializers.CharField(source='get_user_type_display')
    rls = serializers.SerializerMethodField()
    x1 = MyField(source='username')

    class Meta:
        model = models.UserInfo
        # fields = "__all__"   # 显示所有字段，但是外键部分只显示ID
        fields = ['id', 'username', 'password', 'ooo', 'rls', 'group', 'x1']

    def get_rls(self, row):
        roles_obj_list = row.roles.all()
        ret = []
        for item in roles_obj_list:
            ret.append({'id': item.id, 'title': item.title})
        return ret

class MyField(serializers.CharField):

    def to_representation(self, value):
        print(value)
        return 'xxxxx'     # 返回值, 这里将返回显示的值写死了,而不是从数据库中去获取

b4.

使用depth, 可以自动序列化连表

class UserInfoSerializer(serializers.ModelSerializer):

    class Meta:
        model = models.UserInfo
        # fields = "__all__"   # 显示所有字段，但是外键部分只显示ID
        fields = ['id', 'username', 'password', 'roles', 'group']
        depth = 1   # 建议值为0~3,默认为0

b5.

自动生成链接

urls.py

urlpatterns = [
    url(r'^(?P<version>[v1|v2]+)/userinfo/$', views.UserInfoView.as_view()),
    url(r'^(?P<version>[v1|v2]+)/usergroup/(?P<xxx>\d+)$', views.UserGroupView.as_view(), name='gp'),
]

views.py

class UserInfoSerializer(serializers.ModelSerializer):
    group = serializers.HyperlinkedIdentityField(view_name='gp', lookup_field='group_id', lookup_url_kwarg='xxx')    #lookup_field 从数据库取值
    class Meta:
        model = models.UserInfo
        fields = ['id', 'username', 'password', 'roles', 'group']
        depth = 0

class UserInfoView(APIView):

    def get(self, request, *args, **kwargs):

        users = models.UserInfo.objects.all()
        ser = UserInfoSerializer(instance=users, many=True, context={'request': request})

        ret = json.dumps(ser.data, ensure_ascii=False)
        return HttpResponse(ret)

class UserGroupSerializer(serializers.ModelSerializer): 

    class Meta:
        model = models.UserGroup
        fields = "__all__"   # 显示所有字段，但是外键部分只显示ID
        # fields = ['id', 'username', 'password', 'roles', 'group']
        # depth = 0

class UserGroupView(APIView):

    def get(self, request, *args, **kwargs):
        pk = kwargs.get('xxx')
        obj = models.UserGroup.objects.filter(pk=pk).first()
        print(obj)
        ser = UserGroupSerializer(instance=obj, many=False)

        ret = json.dumps(ser.data, ensure_ascii=False)
        return HttpResponse(ret)　

引申知识点: 如何判断一个变量是否是函数

import types
def func(arg):
    # if callable(arg):
    if isinstance(arg, types.FunctionType):
        print(arg())
    else:
        print(arg)

func(123)
func(lambda :"666")

二十、验证用户请求数据

这里我们使用的解析器是: ['rest_framework.parsers.JSONParser', 'rest_framework.parsers.FormParser']

所以提交的验证数据为:

class XXValidator(object):
    def __init__(self, base):
        self.base = base

    def __call__(self, value,  *args, **kwargs):   # 这里的value是用户提交的数据
        if not value.startswith(self.base):
            message = '标题必须以 %s 开头' %self.base
            raise serializers.ValidationError(message)

    def set_context(self, seralizer_field):
        pass
class GroupSerializer(serializers.Serializer):
    title = serializers.CharField(error_messages={'required': '标题不能为空'}, validators=[XXValidator('老男人')])    # validator表示自定义验证规则, 

class GroupView(APIView):

    def post(self, request, *args, **kwargs):

        ser = GroupSerializer(data=request.data)    # request.data 获取请求体中的数据
        if ser.is_valid():
            print(ser.validated_data)
        else:
            print(ser.errors)            # 输出   {'title': ['标题必须以 老男人 开头']}

        return HttpResponse('提交数据')

　验证钩子

class GroupSerializer(serializers.Serializer):
    title = serializers.CharField(error_messages={'required': '标题不能为空'}, validators=[XXValidator('老男人')])

    def validate_title(self, value):   # 这里的value是验证的消息,是ser.validated_data,数据通过验证，会走这个钩子函数
        from rest_framework import exceptions
        # raise exceptions.ValidationError('哈哈哈')
        print(value, "xxxxx")
        return value

二十一、渲染器

from api.utils.serializers.pager import PagerSerializer
from rest_framework.response import Response
class Pager1View(APIView):

    def get(self, request, *args, **kwargs):

        roles = models.Role.objects.all()
        ser = PagerSerializer(instance=roles, many=True)
        return Response(ser.data)    # 使用渲染器显示接口数据

为什么会展示上面的内容呢?

from rest_framework.renderers import JSONRenderer,BrowsableAPIRenderer   # 默认使用的渲染器是这里的全部的渲染器

		class TestView(APIView):
			# renderer_classes = [JSONRenderer,BrowsableAPIRenderer]    # 可以在这里定义该视图使用的渲染器，
			def get(self, request, *args, **kwargs):
				# 获取所有数据
				roles = models.Role.objects.all()

				# 创建分页对象
				# pg = CursorPagination()
				pg = MyCursorPagination()

				# 在数据库中获取分页的数据
				pager_roles = pg.paginate_queryset(queryset=roles, request=request, view=self)

				# 对数据进行序列化
				ser = PagerSerialiser(instance=pager_roles, many=True)

				return Response(ser.data)

# 也可以使用全局的配置，配置默认的渲染器
		REST_FRAMEWORK = {
			"DEFAULT_RENDERER_CLASSES":[
				'rest_framework.renderers.JSONRenderer',
				'rest_framework.renderers.BrowsableAPIRenderer',
			]
		}

当然，我们可以继承上面的渲染器,然后自定制自己的显示页面等内容:

class BrowsableAPIRenderer(BaseRenderer):
    """
    HTML renderer used to self-document the API.
    """
    media_type = 'text/html'
    format = 'api'
    template = 'rest_framework/api.html'     # 这里页面的内容，我们可以进行在子类中替换,哈哈哈哈
    filter_template = 'rest_framework/filters/base.html'
    code_style = 'emacs'
    charset = 'utf-8'
    form_renderer_class = HTMLFormRenderer

　　

二十二、分页器

#自定义序列化的类

#pager.py
from rest_framework import serializers
from  api import models

class PagerSerializer(serializers.ModelSerializer):
    class Meta:
        model = models.Role
        fields = "__all__"

22.1

#分页

REST_FRAMEWORK = {
    'PAGE_SIZE': 2,     # 定义每页分页的大小
}

class Pager1View(APIView):

    def get(self, request, *args, **kwargs):

        #获取所有数据
        roles = models.Role.objects.all()

        # 创建分页对象
        pg = PageNumberPagination()

        # 在数据库中获取分页的数据
        pager_roles = pg.paginate_queryset(queryset=roles, request=request, view=self)   # 返回的是分页的对象

        # 对分页的数据进行序列化
        ser = PagerSerializer(instance=pager_roles, many=True)
        print(pager_roles)
        return Response(ser.data)

22.2

除此之外，我们还可以自定义分页的大小，通过自定义的类来实现:

class MyPageNumberPagination(PageNumberPagination):
    page_size = 2
    page_query_param = 'page'    # 查询分页时使用的参数
    page_size_query_param = 'size'  # 是否可以自定义查询分页的大小

    max_page_size = 5  # 每个分页的最大值

class Pager1View(APIView):

    def get(self, request, *args, **kwargs):

        #获取所有数据
        roles = models.Role.objects.all()

        # 创建分页对象
        pg = MyPageNumberPagination()   # 自定义的分页类

        # 在数据库中获取分页的数据
        pager_roles = pg.paginate_queryset(queryset=roles, request=request, view=self)

        # 对分页的数据进行序列化
        ser = PagerSerializer(instance=pager_roles, many=True)
        print(pager_roles)
        return Response(ser.data)

22.3

如果返回为:

        ser = PagerSerializer(instance=pager_roles, many=True)
        print(pager_roles)
        # return Response(ser.data)
        return pg.get_paginated_response(ser.data)

则显示如下的内容:

22.4

另外使用LimitOffsetPagination也可以实现上述功能

from rest_framework.pagination import LimitOffsetPagination

class LimitOffsetPagination(BasePagination):
    """
    A limit/offset based style. For example:

    http://api.example.org/accounts/?limit=100
    http://api.example.org/accounts/?offset=400&limit=100    # offset 是从0开始的
    """
    default_limit = api_settings.PAGE_SIZE
    limit_query_param = 'limit'
    limit_query_description = _('Number of results to return per page.')
    offset_query_param = 'offset'
    offset_query_description = _('The initial index from which to return the results.')
    max_limit = None
    template = 'rest_framework/pagination/numbers.html'

22.5 加密分页

from rest_framework.pagination import PageNumberPagination, LimitOffsetPagination, CursorPagination

class MyPageNumberPagination(CursorPagination):
    cursor_query_param = 'cursor'    # 查询页的ID
    page_size = 2
    ordering = '-id'     # 排序
    page_size_query_param = None
    max_page_size = None

二十三、 rest framework之视图

23.1  GenericAPIView

从源码看，GenericAPIView是继承了APIView, 实现的功能和APIView没有任何区别，做了解即可:

继承的顺序是View-->APIView--> GenericView

class APIView(View):

    # The following policies ma

class GenericAPIView(views.APIView):
    """
    Base class for all other generic views.

实现代码如下:

from rest_framework.pagination import PageNumberPagination
from api.utils.serializers.pager import PagerSerializer
from rest_framework.generics import GenericAPIView
class View1View(GenericAPIView):
    queryset = models.Role.objects.all()
    serializer_class = PagerSerializer
    pagination_class = PageNumberPagination
    def get(self, request, *args, **kwargs):
        # 获取数据
        roles = self.get_queryset()   # models.Role.objects.all()
        pager_roles = self.paginate_queryset(roles)

        # 序列化
        ser = self.get_serializer(instance=pager_roles, many=True)
        return Response(ser.data)

23.2 GenericViewSet

与上面的GenericAPIView不同的是，重写了as_view()方法;

# 继承了ViewSetMixin和GenericAPIView两个类,ViewSetMixin中重写了as_view方法;

class GenericViewSet(ViewSetMixin, generics.GenericAPIView):
    """
    The GenericViewSet class does not provide any actions by default,
    but does include the base set of generic view behavior, such as
    the `get_object` and `get_queryset` methods.
    """
    pass

class ViewSetMixin(object):
    """
    This is the magic.

    Overrides `.as_view()` so that it takes an `actions` keyword that performs
    the binding of HTTP methods to actions on the Resource.

    For example, to create a concrete view binding the 'GET' and 'POST' methods
    to the 'list' and 'create' actions...

    view = MyViewSet.as_view({'get': 'list', 'post': 'create'})
    """

    @classonlymethod
    def as_view(cls, actions=None, **initkwargs):
        """
        Because of the way class based views create a closure around the
        instantiated view, we need to totally reimplement `.as_view`,
        and slightly modify the view function that is created and returned.
        """
        # The suffix initkwarg is reserved for displaying the viewset type.
        # eg. 'List' or 'Instance'.
        cls.suffix = None

        # Setting a basename allows a view to reverse its action urls. This
        # value is provided by the router through the initkwargs.
        cls.basename = None

实现代码:

urls.py

url(r'^(?P<version>[v1|v2]+)/v1/$', views.View1View.as_view({'get': 'list'})),   # method为GET时，去寻找视图类中的list方法;

views.py

from rest_framework.viewsets import GenericViewSet
class View1View(GenericViewSet):
    queryset = models.Role.objects.all()
    serializer_class = PagerSerializer
    pagination_class = PageNumberPagination
    def list(self, request, *args, **kwargs):   # list方法必须要实现
        # 获取数据
        roles = self.get_queryset()   # models.Role.objects.all()
        pager_roles = self.paginate_queryset(roles)

        # 序列化
        ser = self.get_serializer(instance=pager_roles, many=True)
        return Response(ser.data)　

23.3 ModelViewSet

ModelViewSet 继承了多个类: 每个类实现了一个特定的方法,在实现的时候，无需在视图中实现这些方法，只需要在as_view中指定方法名就可以了

class ModelViewSet(mixins.CreateModelMixin,
                   mixins.RetrieveModelMixin,
                   mixins.UpdateModelMixin,
                   mixins.DestroyModelMixin,
                   mixins.ListModelMixin,
                   GenericViewSet):
    """
    A viewset that provides default `create()`, `retrieve()`, `update()`,
    `partial_update()`, `destroy()` and `list()` actions.
    """
    pass

实现代码:

urls.py

 url(r'^(?P<version>[v1|v2]+)/v1/$', views.View1View.as_view({'get': 'list', 'post':'create'})),    # 获取列表和创建数据无需传递id
    url(r'^(?P<version>[v1|v2]+)/v1/(?P<pk>\d+)$', views.View1View.as_view({'get': 'retrieve', 'delete': 'destroy', 'put': 'update', 'patch': 'partial_update'})),    # 因为update、delete等操作，需要传递id，所以在实现的时候，需要两个路由;

views.py

from rest_framework.viewsets import ModelViewSet
class View1View(ModelViewSet):
    queryset = models.Role.objects.all()
    serializer_class = PagerSerializer
    pagination_class = PageNumberPagination

当然了，也可以只继承mixins中的任意一个或者多个类;

总结使用:

			a. 增删改查  使用ModelViewSet
			b. 增删     使用CreateModelMixin,DestroyModelMixin  GenericViewSet
			c. 复杂逻辑  使用GenericViewSet 或 APIView

　　

二十四、路由

一般一个视图，我们最多写四个url就够了

# http://127.0.0.1:8000/api/v1/v1/?format=json
url(r'^(?P<version>[v1|v2]+)/v1/$', views.View1View.as_view({'get': 'list','post':'create'})),
# http://127.0.0.1:8000/api/v1/v1.json
url(r'^(?P<version>[v1|v2]+)/v1\.(?P<format>\w+)$', views.View1View.as_view({'get': 'list','post':'create'})),
url(r'^(?P<version>[v1|v2]+)/v1/(?P<pk>\d+)/$', views.View1View.as_view({'get': 'retrieve','delete':'destroy','put':'update','patch':'partial_update'})),
url(r'^(?P<version>[v1|v2]+)/v1/(?P<pk>\d+)\.(?P<format>\w+)$', views.View1View.as_view({'get': 'retrieve','delete':'destroy','put':'update','patch':'partial_update'})),

　　

如果嫌麻烦，可以使用全自动路由:

from api import views
from rest_framework import routers

router = routers.DefaultRouter()
router.register(r'xxxxx', views.View1View)
router.register(r'rt', views.View1View)

urlpatterns = [
    url(r'^(?P<version>[v1|v2]+)/', include(router.urls)),
]

　　

如果写单个url就自己写，如果写全部的增删改查就自动生成;

二十五、content-type

在做前后端分离的时候，涉及跨域的问题,解决办法:

1. jsonp

2. cors:  - 将这个响应头放在中间件中进行实现;

content-type: 是django内置的组件，帮助开发者做连表操作。

from django.db import models

# Create your models here.

from django.contrib.contenttypes.models import ContentType
from django.contrib.contenttypes.fields import GenericForeignKey, GenericRelation

class Course(models.Model):
    """
    普通课程
    """
    title = models.CharField(max_length=12)
    # 仅用于反向查找
    price_policy_list = GenericRelation("PricePlicy")

class DegreeCourse(models.Model):
    """
    学位课程
    """
    title = models.CharField(max_length=32)
    price_policy_list = GenericRelation("PricePlicy")

class PricePlicy(models.Model):
    """
    价格策略
    """
    price = models.IntegerField()
    period = models.IntegerField()

    content_type = models.ForeignKey(ContentType, verbose_name='关联的表的名称')
    object_id = models.IntegerField(verbose_name='关联的表中的数据行的ID')
    # 快速实现content_type 操作
    content_object = GenericForeignKey('content_type', 'object_id')   # 会自动找到obj 对象的id和关联的表中的数据行的ID，并进行赋值

obj = DegreeCourse.objects.filter(title='python').first()
PricePlicy.objects.create(price=9.9, period=30, content_object=obj)

　

视图函数

from app01 import models

def test(request):
    obj1 = models.DegreeCourse.objects.filter(title='python').first()
    models.PricePlicy.objects.create(price=9.9, period=30, content_object=obj1)

    obj1 = models.Course.objects.filter(title='rest framework').first()
    models.PricePlicy.objects.create(price=9.9, period=30, content_object=obj1)
    course = models.Course.objects.filter(id=1).first()
    price_policys = course.price_policy_list.all()
    print(price_policys)
    return HttpResponse('....')