Django Rest Framework源码剖析(四)—–API版本详解编程语言

#!/usr/bin/env python3 
#_*_ coding:utf-8 _*_ 
#Author:wd 
from  rest_framework.versioning import BaseVersioning 
 
class Myversion(BaseVersioning): 
    def determine_version(self, request, *args, **kwargs): 
        myversion=request.query_params.get('version') 
        return myversion

class OrderView(APIView): 
    '''查看订单''' 
    from utils.permissions import MyPremission 
    from utils.version import Myversion 
    authentication_classes = [Authentication,]    #添加认证 
    permission_classes = [MyPremission,]           #添加权限控制 
    versioning_class = Myversion   #添加版本 
    def get(self,request,*args,**kwargs): 
        print(request.version)#获取版本 
         #当然使用request._request.get('version')也可以 
        ret = {'code':1000,'msg':"你的订单已经完成",'data':"买了一个mac"} 
        return JsonResponse(ret,safe=True)

from django.db import models 
 
class UserInfo(models.Model): 
    user_type_choice = ( 
        (1,"普通用户"), 
        (2,"会员"), 
    ) 
    user_type = models.IntegerField(choices=user_type_choice) 
    username = models.CharField(max_length=32,unique=True) 
    password = models.CharField(max_length=64) 
 
 
class UserToken(models.Model): 
    user = models.OneToOneField(to=UserInfo) 
    token = models.CharField(max_length=64)

from django.conf.urls import url 
from django.contrib import admin 
from app01 import views 
 
urlpatterns = [ 
 
    url(r'^api/v1/auth', views.AuthView.as_view()), 
    url(r'^api/v1/order', views.OrderView.as_view()), 
]

from django.shortcuts import  HttpResponse 
from django.http import JsonResponse 
from rest_framework.views import APIView 
from rest_framework.authentication import BaseAuthentication 
from . import models 
from rest_framework import exceptions 
import hashlib 
import time 
class Authentication(BaseAuthentication): 
""" 
认证类 
""" 
def authenticate(self, request): 
token = request._request.GET.get("token") 
toke_obj = models.UserToken.objects.filter(token=token).first() 
if not toke_obj: 
raise exceptions.AuthenticationFailed("用户认证失败") 
return (toke_obj.user, toke_obj)  # 这里返回值一次给request.user,request.auth 
def authenticate_header(self, val): 
pass 
def md5(user): 
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 dispatch(self, request, *args, **kwargs): 
return super(AuthView, self).dispatch(request, *args, **kwargs) 
def get(self, request, *args, **kwargs): 
return HttpResponse('get') 
def post(self, request, *args, **kwargs): 
ret = {'code': 1000, 'msg': "登录成功"} 
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'] = "用户名或密码错误" 
else: 
token = md5(user) 
models.UserToken.objects.update_or_create(user=obj, defaults={"token": token}) 
ret['token'] = token 
except Exception as e: 
ret['code'] = 1002 
ret['msg'] = "请求异常" 
return JsonResponse(ret) 
class OrderView(APIView): 
'''查看订单''' 
from utils.permissions import MyPremission 
from utils.version import Myversion 
authentication_classes = [Authentication,]    #添加认证 
permission_classes = [MyPremission,]           #添加权限控制 
versioning_class = Myversion 
def get(self,request,*args,**kwargs): 
print(request.version) 
ret = {'code':1000,'msg':"你的订单已经完成",'data':"买了一个mac"} 
return JsonResponse(ret,safe=True)

class OrderView(APIView): 
'''查看订单''' 
from utils.permissions import MyPremission 
from utils.version import Myversion 
from rest_framework.versioning import QueryParameterVersioning 
authentication_classes = [Authentication,]    #添加认证 
permission_classes = [MyPremission,]           #添加权限控制 
  versioning_class = QueryParameterVersioning #该方法获取参数的key为version 
def get(self,request,*args,**kwargs): 
print(request.version) 
ret = {'code':1000,'msg':"你的订单已经完成",'data':"买了一个mac"} 
return JsonResponse(ret,safe=True)

REST_FRAMEWORK = {#版本配置 
"DEFAULT_VERSION":'v1',               #默认的版本 
"ALLOWED_VERSIONS":['v1','v2'],       #允许的版本,这里只允许V1和v2 
"VERSION_PARAM":'version' ,            #get方式url中参数的名字 如?version=v1 
 
}

from django.conf.urls import url 
from django.contrib import admin 
from app01 import views 
urlpatterns = [ 
url(r'^api/v1/auth', views.AuthView.as_view()), 
url(r'^api/v1/order', views.OrderView.as_view()), 
 url(r'^api/(?P<version>[v1|v2]+)/user', views.UserView.as_view()), # 新建的url 
]

class UserView(APIView): 
'''查看用户信息''' 
from rest_framework.versioning import URLPathVersioning 
versioning_class =URLPathVersioning 
def get(self,request,*args,**kwargs): 
print(request.version)  #获取版本 
res={"name":"wd","age":22} 
return JsonResponse(res,safe=True)

def dispatch(self, request, *args, **kwargs): 
""" 
`.dispatch()` is pretty much the same as Django's regular dispatch, 
but with extra hooks for startup, finalize, and exception handling. 
""" 
self.args = args 
self.kwargs = kwargs 
#对原始request进行加工，丰富了一些功能 
#Request( 
#     request, 
#     parsers=self.get_parsers(), 
#     authenticators=self.get_authenticators(), 
#     negotiator=self.get_content_negotiator(), 
#     parser_context=parser_context 
# ) 
#request(原始request,[BasicAuthentications对象，]) 
#获取原生request,request._request 
#获取认证类的对象，request.authticators 
#1.封装request 
request = self.initialize_request(request, *args, **kwargs) 
self.request = request 
self.headers = self.default_response_headers  # deprecate? 
try: 
self.initial(request, *args, **kwargs) 
# Get the appropriate handler method 
if request.method.lower() in self.http_method_names: 
handler = getattr(self, request.method.lower(), 
self.http_method_not_allowed) 
else: 
handler = self.http_method_not_allowed 
response = handler(request, *args, **kwargs) 
except Exception as exc: 
response = self.handle_exception(exc) 
self.response = self.finalize_response(request, response, *args, **kwargs) 
return self.response

def initial(self, request, *args, **kwargs): 
""" 
Runs anything that needs to occur prior to calling the method handler. 
""" 
self.format_kwarg = self.get_format_suffix(**kwargs) 
# Perform content negotiation and store the accepted info on the request 
neg = self.perform_content_negotiation(request) 
request.accepted_renderer, request.accepted_media_type = neg 
# Determine the API version, if versioning is in use. 
####版本控制 
version, scheme = self.determine_version(request, *args, **kwargs) 
request.version, request.versioning_scheme = version, scheme 
# Ensure that the incoming request is permitted 
#2.实现认证 
        self.perform_authentication(request) 
#3.权限判断 
        self.check_permissions(request) 
#4.频率限制 
self.check_throttles(request)  

    def determine_version(self, request, *args, **kwargs): 
""" 
If versioning is being used, then determine any API version for the 
incoming request. Returns a two-tuple of (version, versioning_scheme) 
""" 
if self.versioning_class is None:  #先判断版本类是否存在(self.versioning_class 是否为存在)，不存在返回tuple，（none,none） 
return (None, None)             
scheme = self.versioning_class()   #存在返回版本类对象 
return (scheme.determine_version(request, *args, **kwargs), scheme) #版本类存在，最后返回版本类对象的determine_version方法结果（也就是返回的版本号），和类对象，
                                                                             这也就是每个版本类必须要有的方法，用来获取版本。

class APIView(View): 
# The following policies may be set at either globally, or per-view. 
renderer_classes = api_settings.DEFAULT_RENDERER_CLASSES 
parser_classes = api_settings.DEFAULT_PARSER_CLASSES 
authentication_classes = api_settings.DEFAULT_AUTHENTICATION_CLASSES 
throttle_classes = api_settings.DEFAULT_THROTTLE_CLASSES 
permission_classes = api_settings.DEFAULT_PERMISSION_CLASSES 
content_negotiation_class = api_settings.DEFAULT_CONTENT_NEGOTIATION_CLASS 
metadata_class = api_settings.DEFAULT_METADATA_CLASS 
versioning_class = api_settings.DEFAULT_VERSIONING_CLASS  #版本处理类配置

class QueryParameterVersioning(BaseVersioning): 
""" 
GET /something/?version=0.1 HTTP/1.1 
Host: example.com 
Accept: application/json 
""" 
invalid_version_message = _('Invalid version in query parameter.')  ## 当setting.py配置了允许的版本时候，不匹配版本返回的错误信息，可以自己定义 
def determine_version(self, request, *args, **kwargs):           ## 获取版本方法 
version = request.query_params.get(self.version_param, self.default_version) # 通过request.query_paras方法获取（本质request.MATE.get），
                                                                                       default_version默认是version，是在settings中配置的 
if not self.is_allowed_version(version):     #不允许的版本抛出异常 
raise exceptions.NotFound(self.invalid_version_message) 
return version  #无异常则返回版本号 
def reverse(self, viewname, args=None, kwargs=None, request=None, format=None, **extra):  #url 反解析，可以通过该方法生成请求的url，后面会有示例 
url = super(QueryParameterVersioning, self).reverse( 
viewname, args, kwargs, request, format, **extra 
) 
if request.version is not None: 
return replace_query_param(url, self.version_param, request.version)    
return url

class URLPathVersioning(BaseVersioning): 
""" 
To the client this is the same style as `NamespaceVersioning`. 
The difference is in the backend - this implementation uses 
Django's URL keyword arguments to determine the version. 
An example URL conf for two views that accept two different versions. 
urlpatterns = [ 
url(r'^(?P<version>[v1|v2]+)/users/$', users_list, name='users-list'), 
url(r'^(?P<version>[v1|v2]+)/users/(?P<pk>[0-9]+)/$', users_detail, name='users-detail') 
] 
GET /1.0/something/ HTTP/1.1 
Host: example.com 
Accept: application/json 
""" 
invalid_version_message = _('Invalid version in URL path.')  # 不允许的版本信息，可定制 
def determine_version(self, request, *args, **kwargs):    ## 同样实现determine_version方法获取版本 
version = kwargs.get(self.version_param, self.default_version) # 由于传递的版本在url的正则中，所以从kwargs中获取，self.version_param默认是version 
if not self.is_allowed_version(version): 
raise exceptions.NotFound(self.invalid_version_message)     # 没获取到，抛出异常 
return version                                                  # 正常获取，返回版本号 
def reverse(self, viewname, args=None, kwargs=None, request=None, format=None, **extra): # url反解析，后面会有示例 
if request.version is not None: 
kwargs = {} if (kwargs is None) else kwargs 
kwargs[self.version_param] = request.version 
return super(URLPathVersioning, self).reverse( 
viewname, args, kwargs, request, format, **extra

class BaseVersioning(object): 
default_version = api_settings.DEFAULT_VERSION            #默默人版本配置 
allowed_versions = api_settings.ALLOWED_VERSIONS　　　　　　#允许版本配置 
version_param = api_settings.VERSION_PARAM                #版本key配置 
def determine_version(self, request, *args, **kwargs): 
msg = '{cls}.determine_version() must be implemented.' 
raise NotImplementedError(msg.format( 
cls=self.__class__.__name__ 
)) 
def reverse(self, viewname, args=None, kwargs=None, request=None, format=None, **extra): 
return _reverse(viewname, args, kwargs, request, format, **extra) 
def is_allowed_version(self, version): 
if not self.allowed_versions: 
return True 
return ((version is not None and version == self.default_version) or 
(version in self.allowed_versions))

urlpatterns = [ 
url(r'^api/v1/auth', views.AuthView.as_view()), 
url(r'^api/v1/order', views.OrderView.as_view()), 
 url(r'^api/(?P<version>[v1|v2]+)/user', views.UserView.as_view(),name="user_view"), 
]

class UserView(APIView): 
'''查看用户信息''' 
from rest_framework.versioning import URLPathVersioning 
versioning_class =URLPathVersioning 
def get(self,request,*args,**kwargs): 
print(request.version) 
url = request.versioning_scheme.reverse(viewname='user_view', request=request) 
#versioning_scheme已经在源码中分析过了，就是版本类实例化的对象 
print(url) 
res={"name":"wd","age":22} 
return JsonResponse(res,safe=True)

# 全局配置 
REST_FRAMEWORK = { 
"DEFAULT_VERSIONING_CLASS":"rest_framework.versioning.URLPathVersioning",  #类的路径 
"DEFAULT_VERSION":'v1',               #默认的版本 
"ALLOWED_VERSIONS":['v1','v2'],       #允许的版本 
 #  "VERSION_PARAM":'version'             #使用QueryParameterVersioning时候进行的配置，get请求时候传递的参数的key   
} 
#单一视图 
versioning_class =URLPathVersioning