django restfulwork 源码剖析

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‘)

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

#!/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()

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‘)

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‘)

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‘)

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(‘删除订单‘)

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‘)　　

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)

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)

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)

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

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

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

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

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()

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)

    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   
}

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信息加入请求头

# 定义权限类
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

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

# 查看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
}

#实现代码：
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

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 = {
    ‘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‘]   # 全局生效
}

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, ]        # 只有用户登录才可以查看订单，使用另外一个访问频率限制类;

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
}

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‘
}

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/

#点击查看源码,
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)
					

#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‘)

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 请求头

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)

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)

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)　　

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)

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

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‘     # 返回值, 这里将返回显示的值写死了,而不是从数据库中去获取

class UserInfoSerializer(serializers.ModelSerializer):

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

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‘),
]

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")

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__"

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)

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)

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

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‘

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

继承的顺序是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)

# 继承了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

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

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)　

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

 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，所以在实现的时候，需要两个路由;

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

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

# 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)),
]

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(‘....‘)