Django Rest Framewoek

1 什么是RESTful

  • REST 指的是一种软件架构风格、设计风格，而不是标准，只是提供了一组设计原则和约束条件。满足这些约束条件和原则的应用程序或设计就是 RESTful。

2 RESTful设计

  • API与用户的通信协议，总是使用HTTPS协议。

  • 域名

    • https://api.example.com 子域名的方式，会存在跨域问题

    • https://example.org/api/ 更简单（推荐）

  • 版本

    • URL，如：https://example.org/api/v1/

    • 请求头，跨域时，引发发送多次请求

  • 路径，视网络上任何东西都是资源，均使用名词表示（可复数）

    • https://api.example.com/v1/zoos

    • https://api.example.com/v1/animals

    • https://api.example.com/v1/employees

  • method

    • GET ：从服务器取出资源（一项或多项）

    • POST：在服务器新建一个资源

    • PUT：在服务器更新资源（客户端提供改变后的完整资源）

    • PATCH：在服务器更新资源，局部更新，比如：只更新某个字段

    • DELETE：从服务器删除资源

  • 过滤，通过在url上传参的形式传递搜索条件

    • https://api.example.com/v1/zoos?limit=10：指定返回记录的数量

    • https://api.example.com/v1/zoos?offset=10：指定返回记录的开始位置

    • https://api.example.com/v1/zoos?page=2&per_page=100：指定第几页，以及每页的记录数

    • https://api.example.com/v1/zoos?sortby=name&order=asc：指定返回结果按照哪个属性排序，以及排序顺序

    • https://api.example.com/v1/zoos?animal_type_id=1：指定筛选条件

  • 状态码

    200 OK - [GET]：服务器成功返回用户请求的数据，该操作是幂等的（Idempotent）。
201 CREATED - [POST/PUT/PATCH]：用户新建或修改数据成功。
202 Accepted - [*]：表示一个请求已经进入后台排队（异步任务）
204 NO CONTENT - [DELETE]：用户删除数据成功。
400 INVALID REQUEST - [POST/PUT/PATCH]：用户发出的请求有错误，服务器没有进行新建或修改数据的操作，该操作是幂等的。
401 Unauthorized - [*]：表示用户没有权限（令牌、用户名、密码错误）。
403 Forbidden - [*] 表示用户得到授权（与401错误相对），但是访问是被禁止的。
404 NOT FOUND - [*]：用户发出的请求针对的是不存在的记录，服务器没有进行操作，该操作是幂等的。
406 Not Acceptable - [GET]：用户请求的格式不可得（比如用户请求JSON格式，但是只有XML格式）。
410 Gone -[GET]：用户请求的资源被永久删除，且不会再得到的。
422 Unprocesable entity - [POST/PUT/PATCH] 当创建一个对象时，发生一个验证错误。
500 INTERNAL SERVER ERROR - [*]：服务器发生错误，用户将无法判断发出的请求是否成功。
​
# 状态码可以自己自定义
    - return HttpResponse(json.dumps(ret),status=800)  # 请求成功会返回800
状态码和code结合的情况。
    更多看这里：http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html

  • 错误处理，状态码是4xx时，应返回错误信息，error当做key。

    {
    error: "Invalid API key"
}

  • 返回结果，针对不同操作，服务器向用户返回的结果应该符合以下规范。

    GET /collection：返回资源对象的列表（数组）
GET /collection/1/：返回单个资源对象
POST /collection：返回新生成的资源对象
PUT /collection/1/：返回完整的资源对象
PATCH /collection/1/：返回完整的资源对象
DELETE /collection/1/：返回一个空文档

  • Hypermedia API，RESTful API最好做到Hypermedia，即返回结果中提供链接，连向其他API方法，使得用户不查文档，也知道下一步应该做什么。

    {"link": {
  "rel":   "collection https://www.example.com/zoos",
  "href":  "https://api.example.com/zoos",
  "title": "List of zoos",
  "type":  "application/vnd.yourformat+json"
}}

3 基于Django Rest Framework框架实现

3.1 安装：

pip3 install djangorestframework

3.2 基本流程

  • View和APIView区别？

    请求和返回使用的DRF的Request、Response，而不是Django的request、HttpResponse；
任何APIException异常都会被捕获到，并且处理成合适的响应信息；
在进行dispatch()分发前，会对请求进行版本获取、身份认证、权限检查、流量控制等操作。

  • 先在django的settings.py中注册rest_framework

    INSTALLED_APPS = [
    ...
    'rest_framework',
]

  • urls.py

    from django.conf.urls import url, include
from web.views.s1_api import TestView
 
urlpatterns = [
    url(r'^test/', TestView.as_view()),
]

  • views.py

    from rest_framework.views import APIView
from rest_framework.response import Response
 
class TestView(APIView):
    def dispatch(self, request, *args, **kwargs):
        """
        请求到来之后，都要执行dispatch方法，dispatch方法根据请求方式不同触发 get/post/put等方法
        注意：APIView中的dispatch方法有好多好多的功能
        """
        return super().dispatch(request, *args, **kwargs)
 
    def get(self, request, *args, **kwargs):
        return Response('GET请求，响应内容')
 
    def post(self, request, *args, **kwargs):
        return Response('POST请求，响应内容')
 
    def put(self, request, *args, **kwargs):
        return Response('PUT请求，响应内容')
    def delete(self, request, *args, **kwargs):
        return Response('DELETE请求，响应内容')

3.3 认证

  • 用户url传入内容认证

    # CBV首先要走的dispatch方法，所以重写dispatch中的内容可以让代码执行前自定义执行某些内容。
​
class MyAuthentication(object):
    def authenticate(self,request):
        username = request._request.GET.get("username")
        print(username)
        obj = models.UserInfo.objects.filter(user=username).first()
        if not obj:
            raise exceptions.AuthenticationFailed("用户认证失败")
        return (obj.user,None)
    def authenticate_header(self,val):
        pass
​
class MyIndex(APIView):
    authentication_classes = [MyAuthentication]  # 加了这个就必须先执行定义的类
    def get(self, request, *args, **kwargs):
        return Response({"get":"get请求"})
    def post(self, request, *args, **kwargs):
        return Response({"post":"post请求"})
    def put(self, request, *args, **kwargs):
        return Response({"put":"put请求"})
    def delete(self, request, *args, **kwargs):
        return Response({"delete":"delete请求"})
    View Code

  • 基于token实现的用户认证

    # model
from django.db import models
​
class User(models.Model):
    username = models.CharField(max_length=12)
    
class Usertoken(models.Model):
    user = models.OneToOneField(to="User")
    token = models.CharField(max_length=64)
    model
    from rest_framework import exceptions
from rest_framework.response import Response
from rest_framework.views import APIView
from app01 import models
class MyAuthentication(object):
    def authenticate(self,request):
        token = request._request.GET.get(token)
        token_obj = models.UserToken.objects.filter(token=token).first()
        if obj:
            return (token_obj.user,token_obj)  # 将元组中user对象和token对象封装到request中
        else:
            raise exceptions.AuthenticationFailed("用户认证失败")
    def authenticate_header(self,val):
        pass
class Order(APIView):
    authentication_classes = [MyAuthentication,]
    def get(self,request,*args,**kwargs):
        # reuqest.user==》token_obj.user
        # request.auth==》token_obj
        return Response({"ret":"请求成功"})
    View Code

  • 认证有三种返回值，一种是返回元组，赋值分别赋值给user和auth封装到request中，一种是返回None，交给下一个认证处理，如果都返回None，那么返回的是一个匿名用户，如果出错则抛出异常。

  • 全局使用，在settings中做如下配置。

    # 在rest_framework的settings.py中，最上面有一段话，例如，项目的“settings.py”文件可能如下所示：
​
REST_FRAMEWORK = {"DEFAULT_AUTHENTICATION_CLASSES":['xxx.xxx.MyAuthentication']}
# 和默认DEFAULTS是一样的写法，只是在我们自己的配置文件中
#此模块用于访问REST framework的配置，先检查用户设置，再检查默认设置DEFAULTS
    View Code

  • 匿名用户

    REST_FRAMEWORK = {
    "DEFAULT_AUTHENTICATION_CLASSES":['xxx.xxx'],
    "UNAUTHENTICATED_USER":None,  # 匿名或者未登录reuqest.user=None
    "UNAUTHENTICATED_TOKEN":None, # 匿名或者未登录request.auth=None
}
    View Code

  • 内置认证类

    使用的时候都继承BaseAuthentication

    from rest_framework.authentication import BaseAuthentication
class MyAuthentication(BaseAuthentication):
    def authenticate(self,request):
        token = request._request.GET.get(token)
        obj = models.UserToken.objects.filter(token=token).first()
        if obj:
            return (obj.user,obj)  # 将元组中的数据封装到request中
        else:
            raise exceptions.AuthenticationFailed("用户认证失败")
    # 直接继承这个类不需要写authenticate_header方法了
    View Code

    BasicAuthentication浏览器对用户名密码加密，放在请求头中发过去的

  • 源码解析

    1.django中的类先执行dispatch方法，Request()对象中封装了原始的self._request=request和authenticators(是一个列表，里面是一个个对象)。authenticators实际上是authentication_classes一个全局配置，使用列表推导式得到的。所以我们要将我们的认证类注册到authentication_classes中，写在我们需要认证的类中。这就是局部认证。全局认证需要我们在配置中按照源码中的配置进行相应的修改，写在我们的配置中。
2.执行initial方法，执行perform_authentication就是用户认证
3.执行request中的user属性
4.执行self._authenticate()方法，循环authenticators，执行authenticate方法，这个方法是必须要写的，也就是我们写认证类时候必须要写的方法，还有一个方法是authenticate_header。需要返回一个元组，将返回值赋值给user和auth
5._not_authenticated方法就是匿名用户
6.实际上我们重写的就是BaseAuthentication类中的方法，所以我们要继承这个类。
7.而其他继承BaseAuthentication这个类的子类，就是内置认证类。
    View Code

3.4权限

  • 权限基本实现

    # model
from django.db import models
​
class User(models.Model):
    usertype_choice = (
        (1,"普通用户"),
        (2,"vip用户"),
        (3,"svip用户"),
    )
    usertype = models.IntegerField(choices=usertype_choice)
    user = models.CharField(max_length=12)
    model
    # 局部添加权限
​
from rest_framework.permissions import BasePermission
​
class Mypermission(BasePermission):
    message = "必须是超级VIP才能访问"  # 这句话就是抛出异常的信息。
    def has_permission(self, request, view):
        if request.user.usertype != 3:  # 不是svip的就没有权限
            return False # 没权限
        return True # 有权限
​
class Order(APIView):
    permission_classes = [Mypermission,]
    def get(self,request,*args,**kwargs):
        return Response({"ret":"请求成功"})
    View Code

  • 全局添加权限

    REST_FRAMEWORK = {
    "DEFAULT_AUTHENTICATION_CLASSES":['xxx.xxx.MyAuthentication'], # 认证
    "DEFAULT_AUTHENTICATION_CLASSES":['xxx.xxx.Mypermission'],  # 权限
}

3.5 访问频率的限制(节流)

  • 匿名用户，我们自己实现的

    # 通过ip限制
from rest_framework.throttling import BaseThrottle
​
VISIT_RECORD = {}  # 最终放在缓存中
LIMIT_TIME = 10
FREQUENCY = 3
​
class VisitThrottle(BaseThrottle):
    """LIMIT_TIME时间内只能访问FREQUENCY次"""
    def __init__(self):
        self.history = None
​
    def allow_request(self, request, view):
        # 获取访问用户的ip地址
        remote_addr = request.META.get('REMOTE_ADDR')
        print(remote_addr)
        ctime = time.time()
        if remote_addr not in VISIT_RECORD:
            VISIT_RECORD[remote_addr] = [ctime, ]
            return True
        history = VISIT_RECORD.get(remote_addr)
        self.history = history
        while history and ctime - history[-1] > LIMIT_TIME:
            history.pop()
        if len(history) < FREQUENCY:
            history.insert(0, ctime)
            return True
    # 再等多久之后就可以访问了，每次刷新都变化，动态的
    def wait(self):
        ctime = time.time()
        # 当当前时间和最早一次访问的时间差等于LIMIT_TIME时间的时候，就可以再次访问
        return LIMIT_TIME-(ctime-self.history[-1])  
    
    class Index(APIView):
        # 局部限制
        throttle_classes = [VisitThrottle,]
​
        def get(self, request, *args, **kwargs):
            print(request.user, request.auth, "******")
            return Response('GET请求，响应内容')
    View Code

  • 全局配置

    REST_FRAMEWORK = {
    "DEFAULT_AUTHENTICATION_CLASSES":['xxx.xxx.MyAuthentication'], # 认证
    "DEFAULT_AUTHENTICATION_CLASSES":['xxx.xxx.Mypermission'],  # 权限
    "DEFAULT_THROTTLE_CLASSES":['xxx.xxx.VisitThrottle'], # 限流
}
    View Code

  • 内置访问频率限制

    SimpleRateThrottle

    # 源码
class SimpleRateThrottle(BaseThrottle):
    """
    A simple cache implementation, that only requires `.get_cache_key()`
    to be overridden.
​
    The rate (requests / seconds) is set by a `rate` attribute on the View
    class.  The attribute is a string of the form 'number_of_requests/period'.
​
    Period should be one of: ('s', 'sec', 'm', 'min', 'h', 'hour', 'd', 'day')
​
    Previous request information used for throttling is stored in the cache.
    """
    cache = default_cache
    timer = time.time
    cache_format = 'throttle_%(scope)s_%(ident)s'
    scope = None
    # 4.这个眼熟啊，就是我们rest_frame的配置项，我们就需要在我们的配置文件中添加DEFAULT_THROTTLE_RATES
    THROTTLE_RATES = api_settings.DEFAULT_THROTTLE_RATES
​
    def __init__(self):
        # 1.找rate，没有执行get_rate()
        if not getattr(self, 'rate', None):
            # 6.self.rate = "3/m"
            self.rate = self.get_rate()
            # 7.将"3/m"给到parse_rate方法
            # 12.从第11步拿到元组(3,60)，分别赋值self.num_requests=3，self.duration=60
        self.num_requests, self.duration = self.parse_rate(self.rate)
​
    def get_cache_key(self, request, view):
        """
        Should return a unique cache-key which can be used for throttling.
        Must be overridden.
​
        May return `None` if the request should not be throttled.
        """
        raise NotImplementedError('.get_cache_key() must be overridden')
​
    def get_rate(self):
        """
        Determine the string representation of the allowed request rate.
        """
        # 2.又找scope，但是scope是None,会抛出异常，说你必须有一个rate或者scope，所以我们用这个类的时候必须给scope赋值
        if not getattr(self, 'scope', None):
            msg = ("You must set either `.scope` or `.rate` for '%s' throttle" %
                   self.__class__.__name__)
            raise ImproperlyConfigured(msg)
​
        try:
            # 3.走到这以后让我们从THROTTLE_RATES取scope，THROTTLE_RATES是我们的类变量
            # 5.从我们设置的配置中获取到scope的值，返回给rate
            return self.THROTTLE_RATES[self.scope]
        except KeyError:
            msg = "No default throttle rate set for '%s' scope" % self.scope
            raise ImproperlyConfigured(msg)
​
    def parse_rate(self, rate):
        """
        Given the request rate string, return a two tuple of:
        <allowed number of requests>, <period of time in seconds>
        """
        if rate is None:
            return (None, None)
        # 8.rate = ‘3/m’，不为空进行字符串切割num = "3"，period = "m"
        num, period = rate.split('/')
        # 9.num_requests = 3
        num_requests = int(num)
        # 10.从字典中取出period[0] = "m"，即duration = 60
        duration = {'s': 1, 'm': 60, 'h': 3600, 'd': 86400}[period[0]]
        # 11.将元组(3,60)返回给第7步
        return (num_requests, duration)
    # 13.通过dispatch方法，可以看出必须要有allow_request方法，执行allow_request方法
    def allow_request(self, request, view):
        """
        Implement the check to see if the request should be throttled.
​
        On success calls `throttle_success`.
        On failure calls `throttle_failure`.
        """
        if self.rate is None:
            return True
        # 14.执行get_cache_key方法，即该方法必须写，
        self.key = self.get_cache_key(request, view)
        if self.key is None:
            return True
        # 15.从django内置缓存中获取到key对应的值（我们将ip或者userid作为key，时间记录列表作为值，那么我们在写get_cache_key方法时就要返回一个ip或者userid，即父类的get_ident方法，就是返回的ip），就是访问时间的记录。
        self.history = self.cache.get(self.key, [])
        self.now = self.timer()
​
        # Drop any requests from the history which have now passed the
        # throttle duration
        # 16.当历史值存在，有访问记录，当第一次访问的时间小于等于当前时间-步骤11的60，证明不是duration时间内的记录，是很久之前的，就将他从列表中删除
        while self.history and self.history[-1] <= self.now - self.duration:
            self.history.pop()
        # 17.历史记录的长度大于等于我们设定的次数，执行throttle_failure方法，返回Flase
        if len(self.history) >= self.num_requests:
            return self.throttle_failure()
        # 18.长度比我们设定的次数小则将当前时间插入到列表第一个位置，并返回True
        return self.throttle_success()
​
    def throttle_success(self):
        """
        Inserts the current request's timestamp along with the key
        into the cache.
        """
        self.history.insert(0, self.now)
        self.cache.set(self.key, self.history, self.duration)
        return True
​
    def throttle_failure(self):
        """
        Called when a request to the API has failed due to throttling.
        """
        return False
​
    def wait(self):
        """
        Returns the recommended next request time in seconds.
        """
        if self.history:
            remaining_duration = self.duration - (self.now - self.history[-1])
        else:
            remaining_duration = self.duration
​
        available_requests = self.num_requests - len(self.history) + 1
        if available_requests <= 0:
            return None
​
        return remaining_duration / float(available_requests)
    View Code

    匿名用户内置限流器

    # 内置限流器我们只需要实现scope这个类变量并重写get_cache_key方法返回self.get_ident(request)，然后在配置中进行下面的配置即可。这是匿名用户的内置限流器
class VisitThrottle(SimpleRateThrottle):
    scope = "love"  # 这个名字可以自定义
    def get_cache_key(self, request, view):
        return self.get_ident(request)  
    
class Index(APIView):
    throttle_classes = [VisitThrottle,]
​
    def get(self, request, *args, **kwargs):
        print(request.user, request.auth, "******")
        return Response('GET请求，响应内容')
    View Code

    配置文件

    REST_FRAMEWORK = {
    "DEFAULT_AUTHENTICATION_CLASSES":['xxx.xxx.MyAuthentication'], # 认证
    "DEFAULT_AUTHENTICATION_CLASSES":['xxx.xxx.Mypermission'],  # 权限
    "DEFAULT_THROTTLE_RATES":{"love":"3/m"}, # 匿名用户限流的
}
    View Code

    登录用户内置限流器

    # 登录的内置限流器，要继承UserRateThrottle，这个类继承的SimpleRateThrottle
class UserThrottle(UserRateThrottle):
    scope = "user"  # 使用用户名，或者用户id
    def get_cache_key(self, request, view):
        # 我们在认证的时候知道request中封装了user和auth，request.user就是user对象
        return request.user.username  # 当前登录用户的用户名
    
class Index(APIView):
    throttle_classes = [UserThrottle,]
​
    def get(self, request, *args, **kwargs):
        print(request.user, request.auth, "******")
        return Response('GET请求，响应内容')
    View Code

    配置文件

    REST_FRAMEWORK = {
    "DEFAULT_AUTHENTICATION_CLASSES":['xxx.xxx.MyAuthentication'], # 认证
    "DEFAULT_AUTHENTICATION_CLASSES":['xxx.xxx.Mypermission'],  # 权限
    "DEFAULT_THROTTLE_RATES":{"love":"3/m"}, # 匿名用户限流的，一分钟访问三次
    "DEFAULT_THROTTLE_RATES":{"user":"10/m"}, # 登录用户限流，一分钟访问10次
}
    View Code

    既有匿名用户也有登录用的情况

    # 登录的内置限流器，要继承UserRateThrottle，这个类继承的SimpleRateThrottle
class VisitThrottle(SimpleRateThrottle):
    scope = "love"  # 这个名字可以自定义
    def get_cache_key(self, request, view):
        return self.get_ident(request)  
​
class UserThrottle(UserRateThrottle):
    scope = "user"  
    def get_cache_key(self, request, view):
        # 我们在认证的时候知道request中封装了user和auth，request.user就是user对象
        return request.user.username  # 当前登录用户的用户名
    
class Index(APIView):
    authentication_classes = [MyAuthentication, ]
    throttle_classes = [VisitThrottle,]
​
    def get(self, request, *args, **kwargs):
        print(request.user, request.auth, "******")
        return Response('GET请求，响应内容')
    View Code
    REST_FRAMEWORK = {
    "DEFAULT_AUTHENTICATION_CLASSES":['xxx.xxx.MyAuthentication'], # 认证
    "DEFAULT_AUTHENTICATION_CLASSES":['xxx.xxx.Mypermission'],  # 权限
    "DEFAULT_THROTTLE_CLASSES":['xxx.xxx.UserThrottle'],  # 登录用户全局设置限流
    # 登录用户可以访问所有，对全局进行限制，匿名用户只能访问部分功能，只对部分功能做匿名用户限流即可，所有匿名用户使用局部方法，如果是匿名用户会优先选择局部的方法进行限流。
    "DEFAULT_THROTTLE_RATES":{"love":"3/m"}, # 匿名用户限流的，一分钟访问三次
    "DEFAULT_THROTTLE_RATES":{"user":"10/m"}, # 登录用户限流，一分钟访问10次
}
    settings.py

3.6 drf中的request

  • 通过我们前几个组件可以看出drf中的request对象并不是我们django中以前使用的request，drf中的request对象封装了我们以前用的request。封装到了_request中，drf通过request._request才是我们以前用的request，所以drf中很多方法属性都要通过request._request获取，但是其实不需要，我们依然可以直接使用request，我们看一下drf源码

    from rest_framework.request import Request  # 从Request中找到下面方法
# drf中的__getattr__方法
def __getattr__(self, attr):
    """
    If an attribute does not exist on this instance, then we also attempt
    to proxy it to the underlying HttpRequest object.
    """
    try:
        # 如果执行我们drf中request没有的方法或属性，就会执行__getattr__方法，然后去request._request中去找对应的方法，即我们原始的request对象中去找
        return getattr(self._request, attr)  
    except AttributeError:
        return self.__getattribute__(attr)
    View Code

  • 当然drf中也封装了很多常用的方法和属性，示例

    from rest_framework.request import Request  # 从Request中找到下面属性
​
@property
def query_params(self):
    """
    More semantically correct name for request.GET.
    """
    return self._request.GET
通过request.query_params ===> request._request.GET
request.query_params.get("xxx") # 取url上的参数
    View Code

3.7 版本组件

  • 版本通过url上传参?version=v1

    自定义版本获取

    # ?version=v1
class MyVersion(object):
    def determine_version(self, request, *args, **kwargs):
        request.query_params.get("version")
        return version
class User(APIView):
    # 局部视图使用
    versioning_class = MyVersion
    def get(self, request, *args, **kwargs):
        print(request.version, "******")
        return Response('GET请求，响应内容')
    View Code

    内置类版本获取

    from rest_framework.versioning import QueryParameterVersioning
​
class User(APIView):
    # 局部视图使用
    versioning_class = QueryParameterVersioning
    def get(self, request, *args, **kwargs):
        print(request.version, "******")
        return Response('GET请求，响应内容')
    
# 配置文件中
REST_FRAMEWORK = {
    "DEFAULT_VERSION":"v1",# 默认版本
    "ALLOWED_VERSIONS":['v1','v2'], # 允许的版本
    "VERSION_PARAM":"version",# 表示的参数的键是什么，比如?version=v1,设置的就是version
}
    局部示例
    # 全局使用
​
class User(APIView):
    def get(self, request, *args, **kwargs):
        print(request.version, "******")
        return Response('GET请求，响应内容')
    
# 配置文件中
REST_FRAMEWORK = {
    "DEFAULT_VERSIONING_CLASS":"rest_framework.versioning.QueryParameterVersioning",
    "DEFAULT_VERSION":"v1",# 默认版本
    "ALLOWED_VERSIONS":['v1','v2'], # 允许的版本
    "VERSION_PARAM":"version",# 表示的参数的键是什么，比如?version=v1,设置的就是version
}
    全局配置应用

  • 版本通过url上路径传参 /v1/user/，推荐这种

    内置版本类

    # urls.py要进行修改
# url上要对应改变
from django.conf.urls import url
from django.contrib import admin
from app01 import views
​
urlpatterns = [
    path('admin/', admin.site.urls),
    url(r'^(?P<version>[v1|v2]+)/user/$', views.User.as_view(), name='users-list'),
]
​
# 视图函数中.py
from rest_framework.versioning import URLPathVersioning
class User(APIView):
    # 局部视图使用
    versioning_class = URLPathVersioning
    def get(self, request, *args, **kwargs):
        print(request.version, "******")
        return Response({"ret":'GET请求，响应内容'})
    
# settings.py
REST_FRAMEWORK = {
    "DEFAULT_VERSION":"v1",# 默认版本
    "ALLOWED_VERSIONS":['v1','v2'], # 允许的版本
    "VERSION_PARAM":"version",# 表示的参数的键是什么，比如?version=v1,设置的就是version
}
    局部示例
    # 全局配置
from django.conf.urls import url
from django.contrib import admin
from app01 import views
​
urlpatterns = [
    path('admin/', admin.site.urls),
    url(r'^(?P<version>[v1|v2]+)/user/$', views.User.as_view(), name='users-list'),
]
​
# 视图函数中.py
class User(APIView):
    def get(self, request, *args, **kwargs):
        print(request.version, "******")
        return Response({"ret":'GET请求，响应内容'})
    
# settings.py
REST_FRAMEWORK = {
    "DEFAULT_VERSIONING_CLASS":"rest_framework.versioning.URLPathVersioning"
    "DEFAULT_VERSION":"v1",# 默认版本
    "ALLOWED_VERSIONS":['v1','v2'], # 允许的版本
    "VERSION_PARAM":"version",# 表示的参数的键是什么，比如?version=v1,设置的就是version
}
    全局配置应用

  • 源码流程

    1.先执行dispatch方法，执行其中的initial方法
2.initial方法中部分源码
    # Determine the API version, if versioning is in use.
    # 获取到版本，和处理版本的对象
    version, scheme = self.determine_version(request, *args, **kwargs)
    # 并将版本号和对象赋值到request，从request中就可以拿到version和处理版本的对象scheme
    request.version, request.versioning_scheme = version, scheme
    
3.determine_version方法就是去实例化我们处理版本的类，并但会版本和处理版本的对象。
4.现在drf执行流程，先进行版本处理--》认证--》权限--》限流
# 在URLPathVersioning或者QueryParameterVersioning中有一个reserve方法，用于反向解析找到url的
# urls.py
urlpatterns = [
    path('admin/', admin.site.urls),
    url(r'^(?P<version>[v1|v2]+)/user/$', views.User.as_view(), name='users-list'),
]
    View Code
    # 视图函数中.py
class User(APIView):
    def get(self, request, *args, **kwargs):
        print(request.version, "******")
        # request.versioning_scheme就是我们处理按本的对象,按照我们自己写的反向解析，传参要将url上正则的分组命名的关键字参数传入，但是使用drf的reserve不需要再传了，我们只需要传个request即可，request里面有个version，自己会加上。没有指定版本会生成当前url的版本
        u1 = request.versioning_scheme.reserve(viewname="users-list",request=request)
        print(u1)
        
        # django的reserve
        from django.urls import reverse
        reserve(viewname="users-list",kwargs={"version":"v1"})
        return Response({"ret":'GET请求，响应内容'}) 

    内置的版本处理有哪些方式？

    QueryParameterVersioning基于url参数做版本处理 如：GET /something/?version=0.1 HTTP/1.1
HostNameVersioning基于域名做的版本处理，如：v1.example.com
NamespaceVersioning基于命名空间做的版本处理，如：
    urlpatterns = [
        url(r'^v1/', include('users.urls', namespace='v1')),
        url(r'^v2/', include('users.urls', namespace='v2'))
    ]
URLPathVersioning基于url路径做的版本处理，如：/v1/user/ ，推荐使用
AcceptHeaderVersioning基于请求头处理的，如：Accept: application/json; version=1.0
    View Code

  • 总结

    1.进行配置
REST_FRAMEWORK = {
    "DEFAULT_VERSIONING_CLASS":"rest_framework.versioning.URLPathVersioning"
    "DEFAULT_VERSION":"v1",# 默认版本
    "ALLOWED_VERSIONS":['v1','v2'], # 允许的版本
    "VERSION_PARAM":"version",# 表示的参数的键是什么，比如?version=v1,设置的就是version
}
2.urls.py，如果有路由分发再使用路由分发
urlpatterns = [
    path('admin/', admin.site.urls),
    url(r'^(?P<version>[v1|v2]+)/user/$', views.User.as_view(), name='users-list'),
]
3.视图中使用
class User(APIView):
    def get(self, request, *args, **kwargs):
        # 1.获取版本
        print(request.version, "******")
        # 2.获取版本处理的对象
        print(request.versioning_scheme)
        # 3.通过drf中的reserve使用版本处理对象进行反向解析
        u1 = request.versioning_scheme.reserve(viewname="users-list",request=request)
        print(u1)
        
        # 4.使用django提供的reserve
        from django.urls import reverse
        reserve(viewname="users-list",kwargs={"version":"v1"})
        return Response({"ret":'GET请求，响应内容'})
    View Code 

3.8 request.body和request.POST

  • request.body中有值，request.POST中不一定有值，想要request.POST中有值，需要满足以下两个条件：

    1.请求头要求
    Content-Type:application/x-www-form-urlencoded,此时request.POST才可能有值（从request.body解析）
2.数据格式的要求
    name=xiaoqi&age=18&gender=女

  • 示例

    1.form表单，默认状态
<form action="" method="post" >
    <input type="text" value="" name="name">  //会自动转换成我们需要的数据格式，携带者请求头
    <input type="submit" value="提交">
</form>
​
2.ajax请求
$.ajax({
    url:"",
    type:"post",
    data:{"name":"xiaoqi"}  //会自动转换成我们需要的数据格式，携带者请求头
})
​
$.ajax({
    url:"",
    type:"post",
    headers:{"Content-Type":"application/json"}, //请求头不符合，body有值，post无值
    data:{"name":"xiaoqi"},  //会自动转换成我们需要的数据格式
    success:function(ret){
        ...
    }
})
​
$.ajax({
    url:"",
    type:"post",
    headers:{"Content-Type":"application/json"}, //请求头不符合，body有值，post无值
    data:JSON.stringfy({"name":"xiaoqi"}),  //数据格式不符合
    success:function(ret){
        ...
    }
})
    View Code

3.9 解析器

  • 解析器：对用户请求体中的数据进行解析，依靠请求头content-type对请求体中的数据进行解析，解析到request.data中。

  • 解析器的使用，

    from rest_framework.parsers import JSONParser,FormParser
​
class MyParse(APIView):
    """
    JSONParser：只支持Content-Type:application/json格式的
    FormParser：只支持Content-Type:application/x-www-form-urlencoded格式的
    """
    parser_classes = [JSONParser,FormParser]  # 表示符合里面那个解析器的请求头，就让谁去处理
    def post(self,request,*args,**kwargs):
        """
        1.获取用户的请求头
        2.获取用户的请求体
        3.根据用户的请求头，和parser_classes中支持的请求头进行比较
        4.谁支持，就让谁处理请求体中内容
        5.处理完成之后将结果交给request.data
        """
        ret = request.data  # 使用request.data取值，内部帮助你反序列化了。不使用它取值，解析器虽然配置上了，但是并没有用
        print(ret)
​
        return HttpResponse("请求成功了")
    View Code

  • 全局使用

    from rest_framework.parsers import FileUploadParser
class MyParse(APIView):
    parser_classes = [FileUploadParser,]  # 表示仅上传文件，不支持全局的
    def post(self,request,*args,**kwargs):
        """
        1.获取用户的请求头
        2.获取用户的请求体
        3.根据用户的请求头，和parser_classes中支持的请求头进行比较
        4.谁支持，就让谁处理请求体中内容
        5.处理完成之后将结果交给request.data
        """
        ret = request.data  
        print(ret)
        return HttpResponse("请求成功了")
    views.py
    # 在settings.py全局配置
REST_FRAMEWORK = {
    'DEFAULT_PARSER_CLASSES': [
        'rest_framework.parsers.JSONParser',
        'rest_framework.parsers.FormParser',
    ],
}
    settings.py 

  • 源码解析

    1.先将所有的解析器封装进request对象中，先执行dispatch方法，parsers=self.get_parsers(),封装在Resquest对象中，parsers = parser_classes（我们写的列表）通过列表推导式得到的对象列表。
2.request.data可以获取到解析后的数据，先执行_load_data_and_files()方法，
3.执行_parse方法，从请求头中获取到content-type的值赋值给media_type
4.执行select_parser(self, self.parsers)方法，其中self.parsers就是我们第1部得到的对象列表
5.循环出parsers中的对象列表，逐一使用media_type_matches方法，让media_type（请求头中的content-type的值）和我们定义的解析器对象parser的media_type类变量做匹配，匹配成功返回对应的解析器对象。
6.然后执行解析器的parse()方法，里面进行了反序列化。
    View Code

3.10 序列化器

3.10.1 继承Serializer

  • 简单使用

    from rest_framework import serializers
class RoleSerializer(serializers.Serializer):
    # 使我们数据库中的字段
    id = serializers.IntegerField()
    title = serializers.CharField()
​
class RolesView(APIView):
    def get(self,request,*args,**kwargs):
        obj_set = models.Role.objects.all()
        # json.dumps只能序列化python中的数据类型，queryset是django中的对象，不能直接序列化
        # 需要使用序列化器，queryset中有多条数据，需要添加many参数
        ser = RoleSerializer(instance=obj_set,many=True)
        # ser.data是序列化之后的结果，是一个有序字典
​
        return Response(ser.data)
    View Code

  • 含选择字段，外键和多对多关系，自定制内容

    # model类
from django.db import models
​
class User(models.Model):
    usertype_choice = (
        (1,"普通用户"),
        (2,"vip用户"),
        (3,"svip用户"),
    )
    usertype = models.IntegerField(choices=usertype_choice)
    user = models.CharField(max_length=12)
    group = models.ForeignKey("UserGroup",on_delete=models.CASCADE)
    roles = models.ManyToManyField("Role")
​
class Role(models.Model):
    title = models.CharField(max_length=32)
​
class UserGroup(models.Model):
    group = models.CharField(max_length=12)
    models.py
    from rest_framework import serializers
class UserSerializer(serializers.Serializer):
    user = serializers.CharField()  # 普通字段
    # choice选择，可通过get_usertype_display获取对应的选择中文值
    utp = serializers.CharField(source="get_usertype_display")
    # 外键
    gp = serializers.CharField(source="group.group")
    # 多对多字段,SerializerMethodField自定义显示
    rol = serializers.SerializerMethodField()
    def get_rol(self,row):
        role_obj_list = row.roles.all()
        ret = []
        for role_obj in role_obj_list:
            ret.append({"id":role_obj.id,"title":role_obj.title})
        return ret
​
class UserView(APIView):
    def get(self,request,*args,**kwargs):
        obj_set = models.User.objects.all()
​
        ser = UserSerializer(instance=obj_set,many=True)
        print(ser.data,type(ser.data))
        return Response(ser.data)
    views.py

3.10.2 继承ModelSerializer

  • 示例

    # model类
from django.db import models
​
class User(models.Model):
    usertype_choice = (
        (1,"普通用户"),
        (2,"vip用户"),
        (3,"svip用户"),
    )
    usertype = models.IntegerField(choices=usertype_choice)
    user = models.CharField(max_length=12)
    group = models.ForeignKey("UserGroup",on_delete=models.CASCADE)
    roles = models.ManyToManyField("Role")
​
class Role(models.Model):
    title = models.CharField(max_length=32)
​
class UserGroup(models.Model):
    group = models.CharField(max_length=12)
    models.py
    from rest_framework import serializers
class UserModelSerializer(serializers.ModelSerializer):
    # choice选择，可通过get_usertype_display获取对应的选择中文值
    utp = serializers.CharField(source="get_usertype_display")  # 不需要手动加括号，内部自动实现
    # 外键
    gp = serializers.CharField(source="group.group")
    # 多对多字段,SerializerMethodField自定义显示
    rol = serializers.SerializerMethodField()
    def get_rol(self,row):  # row就是对应model的对象，函数名必须是get_xxx,xxx是显示的字段名
        role_obj_list = row.roles.all()
        ret = []
        for role_obj in role_obj_list:
            ret.append({"id":role_obj.id,"title":role_obj.title})
        return ret
    
    class Meta:
        model = models.User
        # fields = "__all__"  # 获取所有字段
        fields = ["id","user","utp","gp","rol"]  # 自定制显示字段
​
class UserView(APIView):
​
    def get(self,request,*args,**kwargs):
        obj_set = models.User.objects.all()
​
        ser = UserModelSerializer(instance=obj_set,many=True)
        print(ser.data,type(ser.data))
        return Response(ser.data)
    views.py

  • 自定制类

    from rest_framework import serializers
​
# 自定制类方式，对数据库的字段进行修改显示
class MyMethod(serializers.CharField):
    def to_representation(self, value):
        # value就是我们去到的user
        return f"叫爸爸，{value}"
​
class UserModelSerializer(serializers.ModelSerializer):
    # choice选择，可通过get_usertype_display获取对应的选择中文值
    utp = serializers.CharField(source="get_usertype_display")  # 不需要手动加括号，内部自动实现
    # 外键
    gp = serializers.CharField(source="group.group")
    # 多对多字段,SerializerMethodField自定义显示
    rol = serializers.SerializerMethodField()
​
    def get_rol(self, row):  # row就是对应model的对象，函数名必须是get_xxx,xxx是显示的字段名
        role_obj_list = row.roles.all()
        ret = []
        for role_obj in role_obj_list:
            ret.append({"id": role_obj.id, "title": role_obj.title})
        return ret
    # 自定制类的显示
    xxx = MyMethod(source="user")
​
    class Meta:
        model = models.User
        # fields = "__all__"  # 获取所有字段
        fields = ["id", "user", "utp", "gp", "rol","xxx"]  # 自定制显示字段
​
class UserView(APIView):
​
    def get(self, request, *args, **kwargs):
        obj_set = models.User.objects.all()
​
        ser = UserModelSerializer(instance=obj_set, many=True)
        print(ser.data, type(ser.data))
        return Response(ser.data)
    View Code

  • 自定制字段，添加model之外的字段，必须定义get_字段名()方法，用于返回字段的值

    class PublisherSerializer(serializers.ModelSerializer):
    social_uid = serializers.CharField(source='original_social_uid', read_only=True)
    social_username = serializers.CharField(source='original_social_username', read_only=True)
    promote = serializers.SerializerMethodField()  # 自定义model中没有的字段
​
    class Meta:
        model = Publisher
        fields = ('social_uid', 'social_username', 'promote')
        read_only_fields = fields
        writable_fields = []
​
    def get_promote(self):
        promote = "hello 我是新增的"
        return promote
    View Code

3.10.3 自动序列化连表操作

  • 牛逼的几个字符，完成3.10.2功能

    from rest_framework import serializers
​
class UserModelSerializer(serializers.ModelSerializer):
    # choice选择，可通过get_usertype_display获取对应的选择中文值
    utp = serializers.CharField(source="get_usertype_display")  # 不需要手动加括号，内部自动实现
    class Meta:
        model = models.User
        fields = ["id","user","utp","group","roles"]
        depth = 1  # 深度，即连表查询的深度，官方建议0-10层，不要超过10层，层数越多越慢
​
class UserView(APIView):
​
    def get(self, request, *args, **kwargs):
        obj_set = models.User.objects.all()
​
        ser = UserModelSerializer(instance=obj_set, many=True)
        print(ser.data, type(ser.data))
        return Response(ser.data)
    View Code

3.10.4生成链接，一对多/多对多

  • urls.py

    urlpatterns = [
    path('admin/', admin.site.urls),
    
    url(r'^userview/$', views.UserView.as_view(),name="user"),
    url(r'^group/(?P<pk>\d+)/$', views.GroupView.as_view(),name="gp"),
    url(r'^role/(?P<pk>\d+)/$', views.RoleView.as_view(),name="rol"),
]
    urls.py

  • 视图函数

    class UserModelSerializer(serializers.ModelSerializer):
    # choice选择，可通过get_usertype_display获取对应的选择中文值
    utp = serializers.CharField(source="get_usertype_display")  # 不需要手动加括号，内部自动实现
    # 针对group字段，反向生成url,
    # view_name表示反向解析地址的路由别名,
    # lookup_field配置路由的Pk,
    # lookup_url_kwarg:反向解析地址路由中分组的名字
    group = serializers.HyperlinkedIdentityField(view_name="gp",lookup_field="group_id",lookup_url_kwarg="pk")
    # 处理多对多关系，亲测有效
    roles = serializers.HyperlinkedIdentityField(view_name="rol",lookup_field="pk",lookup_url_kwarg="pk",many=True)
    class Meta:
        model = models.User
        fields = ["id","user","utp","group","roles"]
        depth = 0
​
class UserView(APIView):
​
    def get(self, request, *args, **kwargs):
        obj_set = models.User.objects.all()
        # 使用HyperlinkedIdentityField必须要实例化序列化器的时候传入context={'request': request}
        ser = UserModelSerializer(instance=obj_set, many=True,context={'request': request})
        print(ser.data, type(ser.data))
        return Response(ser.data)
​
class GroupSerializer(serializers.ModelSerializer):
    class Meta:
        model = models.UserGroup
        fields = "__all__"
​
class GroupView(APIView):
    def get(self, request, *args, **kwargs):
        pk = kwargs.get("pk")  # 取关键字参数
        obj = models.UserGroup.objects.get(pk=pk)
        ser = GroupSerializer(instance=obj)
        return Response(ser.data)
    
class RoleSerializer(serializers.ModelSerializer):
    class Meta:
        model = models.Role
        fields = "__all__"
​
class RoleView(APIView):
    def get(self, request, *args, **kwargs):
        pk = kwargs.get("pk")  # 取关键字参数
        obj = models.Role.objects.get(pk=pk)
        ser = RoleSerializer(instance=obj)
​
        return Response(ser.data)
    views.py

  • 源码流程

    类实例化先执行__new__方法，执行BaseSerializer类的__new__方法，如果参数传了many=True，为Queryset类型
    对象，通过Serializer类处理
    Queryset，通过ListSerializer类处理
查看源码从ser.data往后看
1.执行data方法，会执行to_representation方法，这个方法先去我们自己写的序列化器中找，没有向上找。
2.从继承的Serializer中可以找到。
3.to_representation中定义了一个有序字典，循环每个字段执行get_attribute方法，字段是通过serializers.CharField()等类的实例化得到的对象，查看CharField类，找到get_attribute方法。
4.CharField()没有，到父类中去找。
5.return get_attribute(instance, self.source_attrs)，instance使我们传入的对象可通过源码流程确认，source_attrs就是我们写的source通过分隔后得到的列表。
6.进入get_attribute中循环attrs即source_attrs，比如外键：
    source="group.group"
    source_attrs = ["group","group"]
7.通过反射去instance即我们查询出的对象中找到group，并赋值给instance，此时instance是group对象，循环后最终instance就是最后的group。
8.下一步判断能否执行，可执行就加括号执行，不可执行跳过，最后返回instance
    View Code

3.10.5 请求数据校验

  • 内置校验

    class DepartmentSerializer(serializers.Serializer):
    # error_messages属性可以定义内置验证的错误提示
    depart = serializers.CharField(error_messages={"required":"该字段不能为空"},)
​
class DepartmentView(APIView):
​
    def post(self,request,*args,**kwargs):
        # 解析器解析后的数据放到了request.data中
        ser = DepartmentSerializer(data=request.data)
        if ser.is_valid():
            # validated_data清洗后的数据
            print(ser.validated_data)
            return Response(ser.validated_data)
        else:
            # errors错误字典
            print(ser.errors)
            return Response(ser.errors)
    View Code

  • 自定义校验器

    class MyValidator(object):
    def __call__(self, value):
        if "健人" in value:
            message = "内容存在敏感字符"
            raise serializers.ValidationError(message)
​
class DepartmentSerializer(serializers.Serializer):
    # error_messages属性可以定义内置验证的错误提示
    # validators自定义验证规则，将我们自定的验证规则，填入到列表中
    depart = serializers.CharField(error_messages={"required": "该字段不能为空"}, validators=[MyValidator(),])
​
class DepartmentView(APIView):
​
    def post(self, request, *args, **kwargs):
        # 解析器解析后的数据放到了request.data中
        ser = DepartmentSerializer(data=request.data)
        if ser.is_valid():
            print(ser.validated_data)
            return Response(ser.validated_data)
        else:
            print(ser.errors)
            return Response(ser.errors)
        
"""
如果我们输入{"depart":"健人就是贱人"}
立马就会提示：
{
    "depart": [
        "内容存在敏感字符"
    ]
}
"""
    View Code

  • 钩子函数

    class DepartmentSerializer(serializers.Serializer):
    # error_messages属性可以定义内置验证的错误提示
    # validators自定义验证规则，将我们自定的验证规则，填入到列表中
    depart = serializers.CharField(error_messages={"required": "该字段不能为空"}, validators=[MyValidator(), ])
    
    # 局部钩子校验
    def validate_depart(self, value):
        print(value, "******")
        if value == "xiaoqi":
            return value
        raise serializers.ValidationError("未通过校验")
    # 全局钩子校验
    def validate(self, attrs):
        print(attrs, "-----------")
        if len(attrs.get("depart")) < 5:
            return attrs
        raise serializers.ValidationError("长度超过限制")
​
class DepartmentView(APIView):
​
    def post(self, request, *args, **kwargs):
        # 解析器解析后的数据放到了request.data中
        ser = DepartmentSerializer(data=request.data)
        if ser.is_valid():
            return Response(ser.validated_data)
        else:
            print(ser.errors)
            return Response(ser.errors)
    View Code

  • 校验流程

    1.执行is_valid()进行校验
2.执行序列化器对象的run_validation()方法进行校验，然后执行to_internal_value()方法，先定义错误字典和数据字典。
3.循环每个字段进行内置校验和自定义校验，执行字段对象的run_validation()方法，执行字段对象中的run_validators(value)方法，进行自定义校验器的校验，循环自定义校验器列表中的每个对象，加括号执行，自动执行__call__方法，即自定义校验器是在__call__方法中进行校验。
4.validate_method()进行局部钩子校验，通过后
5.执行序列化器对象的validate(self, attrs)方法，进行全局钩子校验。
6.最终将通过校验的值赋给validated_data
    View Code

3.11 分页

3.11.1 看第几页，每页显示n条数据

  • 简单分页

    from rest_framework.pagination import PageNumberPagination
​
class DepartmentSerializer(serializers.ModelSerializer):
    class Meta:
        model = models.Department
        fields = "__all__"
​
class PageView(APIView):
    def get(self, request, *args, **kwargs):
        obj_list = models.Department.objects.all()
        print(obj_list)
        # 实例化分页对象
        pg = PageNumberPagination()
        # 在数据库中获取分页数据
        pg_obj_list = pg.paginate_queryset(queryset=obj_list, request=request, view=self)
        # 对数据进行序列化
        ser = DepartmentSerializer(instance=pg_obj_list, many=True)
​
        return Response(ser.data)
    views.py
    # 配置中需要设置每页显示几条数据
REST_FRAMEWORK = {
    "PAGE_SIZE":2,
}
    settings.py

  • 自定制内容

    from rest_framework.pagination import PageNumberPagination
​
class DepartmentSerializer(serializers.ModelSerializer):
    class Meta:
        model = models.Department
        fields = "__all__"
class MyPageNumberPagination(PageNumberPagination):
    page_size = 2  # size配置成2，每页显示2条数据
    # 表示还可以传一个size参数，size我们定义的是2，还可以自定制一页显示多少条数据
    page_size_query_param = 'size'
    # 每页最多能够显示数据条数
    max_page_size = 5
    # 就是url页码参数的名字
    page_query_param = 'page'
​
class PageView(APIView):
    def get(self, request, *args, **kwargs):
        obj_list = models.Department.objects.all()
        print(obj_list)
        # 实例化分页对象
        mpg = MyPageNumberPagination()
        # 在数据库中获取分页数据
        pg_obj_list = mpg.paginate_queryset(queryset=obj_list, request=request, view=self)
        ser = DepartmentSerializer(instance=pg_obj_list, many=True)
        # 可以给我们返回一个response,样式如下
        ret = mpg.get_paginated_response(ser.data)
        return ret
        # return Response(ser.data)
# 使用mpg.get_paginated_response(ser.data)样式：可以提供上一页下一页的url，和数据条数
{
    "count": 10,
    "next": "http://127.0.0.1:8000/depart/?page=3",
    "previous": "http://127.0.0.1:8000/depart/",
    "results": [
        {
            "id": 3,
            "depart": "运维"
        },
        {
            "id": 4,
            "depart": "销售"
        }
    ]
}
    View Code

3.11.2 在n的索引位置，向后查看n条数据

  • 分页实现

    from rest_framework.pagination import LimitOffsetPagination
​
class DepartmentSerializer(serializers.ModelSerializer):
    class Meta:
        model = models.Department
        fields = "__all__"
class MyLimitOffsetPagination(LimitOffsetPagination):
    default_limit = 2  # 默认每页显示多少条数据
    offset_query_param = 'offset' # 从索引为几的数据开始查看,0是第一条
    limit_query_param = 'limit' # 可以设定显示条数
    max_limit = 5 # 最大显示多少条
​
class PageView(APIView):
    def get(self, request, *args, **kwargs):
        obj_list = models.Department.objects.all()
        print(obj_list)
        # 实例化分页对象
        pg = MyLimitOffsetPagination()
        # 在数据库中获取分页数据
        pg_obj_list = pg.paginate_queryset(queryset=obj_list, request=request, view=self)
        ser = DepartmentSerializer(instance=pg_obj_list, many=True)
        # 可以给我们返回一个response
        # ret = pg.get_paginated_response(ser.data)
        # return ret
        return Response(ser.data)
    View Code

3.11.3 加密分页，只有上一页下一页

  • 分页实现，这种方式实际上是记住当前页的最大值和最小值，下一页时就按照最大值向后读n条数据，上一页则按照最小值向前读n条数据。

    from rest_framework.pagination import CursorPagination
​
class DepartmentSerializer(serializers.ModelSerializer):
    class Meta:
        model = models.Department
        fields = "__all__"
class MyCursorPagination(CursorPagination):
    # url参数名称
    cursor_query_param = 'cursor'
    page_size = 2 # 一页显示2条数据
    # 排序规则，按照什么排序
    ordering = 'id'
    # 可以设定显示条数,如在url上添加?page_size=4,每页显示4条数据
    page_size_query_param = "page_size"
    # 最多显示多少条数据
    max_page_size = 5
​
class PageView(APIView):
    def get(self, request, *args, **kwargs):
        obj_list = models.Department.objects.all()
        print(obj_list)
        # 实例化分页对象
        pg = MyCursorPagination()
        # 在数据库中获取分页数据
        pg_obj_list = pg.paginate_queryset(queryset=obj_list, request=request, view=self)
        ser = DepartmentSerializer(instance=pg_obj_list, many=True)
        # 可以给我们返回一个response,page经过加密了，我们无法直接在url输入页码，只能以这种形式返回
        ret = pg.get_paginated_response(ser.data)
        return ret
    View Code

3.12 视图

  • GenericAPIView继承APIView，APIView继承View

    GenericAPIView作用实际只是通过内部一些方法，帮我们调用类变量中的配置的数据对象，分页器和序列化器。

    # url(r'^books/(?P<pk>\d+)/$', views.TestView.as_view()),
​
from rest_framework.generics import GenericAPIView
​
class UserSerializer(serializers.Serializer):
    user = serializers.CharField()  # 普通字段
    # choice选择，可通过get_usertype_display获取对应的选择中文值
    utp = serializers.CharField(source="get_usertype_display")
    # 外键
    gp = serializers.CharField(source="group.group")
    # 多对多字段,SerializerMethodField自定义显示
    rol = serializers.SerializerMethodField()
​
    def get_rol(self, row):
        role_obj_list = row.roles.all()
        ret = []
        for role_obj in role_obj_list:
            ret.append({"id": role_obj.id, "title": role_obj.title})
        return ret
​
class TestView(GenericAPIView):
    queryset = UserInfo.objects.all()
    serializer_class = UserSerializer
    pagination_class = PageNumberPagination
 
    def get(self, request, pk):
        # 获取数据,get_queryset()方法实际上就是去获取类变量queryset的值
        query_set = self.get_queryset()
        # 分页，获取类变量serializer_class实例化后的对象
        pg = self.paginate_queryset(query_set)
        # 序列化，获取类变量pagination_class实例化后的对象
        ser = self.get_serializer(instance=pg,many=True)
        return Response(ser.data)
    View Code

  • 在权限位置有一个方法has_object_permission()，只有执行GenericAPIView中的get_object方法是会调用

    # 流程
GenericAPIView
    1.执行get_object方法
    2.会执行check_object_permissions方法
    3.会循环执行has_object_permission方法，此时使用权限组件的时候必须写has_object_permission方法
    View Code

  • GenericViewSet(ViewSetMixin, generics.GenericAPIView)

    主要的作用不在GenericAPIView，而是继承的ViewSetMixin，ViewSetMixin的作用主要是重写as_view()方法，可以在路由上自定义绑定方法名。

    # urls.py
from django.conf.urls import url, include
from web.views.s7_viewset import TestView
​
urlpatterns = [
    # 路由中修改了方法的对应关系，ViewSetMixin的主要作用
    url(r'test/', TestView.as_view({'get':'list'}), name='test'),
]
    urls.py
    from rest_framework.response import Response
from rest_framework.viewsets import GenericViewSet
from app01 import models
​
class UserSerializer(serializers.Serializer):
    user = serializers.CharField()  # 普通字段
    # choice选择，可通过get_usertype_display获取对应的选择中文值
    utp = serializers.CharField(source="get_usertype_display")
    # 外键
    gp = serializers.CharField(source="group.group")
    # 多对多字段,SerializerMethodField自定义显示
    rol = serializers.SerializerMethodField()
​
    def get_rol(self, row):
        role_obj_list = row.roles.all()
        ret = []
        for role_obj in role_obj_list:
            ret.append({"id": role_obj.id, "title": role_obj.title})
        return ret
​
class TestView(GenericViewSet):
    queryset = models.UserInfo.objects.all()
    serializer_class = UserSerializer
    pagination_class = PageNumberPagination  # 如果有自定义部分可以使用自己自定义的
    
    def list(self, request, *args, **kwargs):
        # 获取数据,get_queryset()方法实际上就是去获取类变量queryset的值
        query_set = self.get_queryset()
        # 分页，获取类变量serializer_class实例化后的对象
        pg = self.paginate_queryset(query_set)
        # 序列化，获取类变量pagination_class实例化后的对象
        ser = self.get_serializer(instance=pg,many=True)
​
        return Response(ser.data)
    views.py

  • ModelViewSet

    主要作用帮助我们完成增删改(包含局部修改)查功能

    # ModelViewSet的继承关系
class ModelViewSet(mixins.CreateModelMixin,
                   mixins.RetrieveModelMixin,
                   mixins.UpdateModelMixin,
                   mixins.DestroyModelMixin,
                   mixins.ListModelMixin,
                   GenericViewSet):
1.mixins.CreateModelMixin：
    create()：帮助我们完成了新增--》post
2.mixins.RetrieveModelMixin：
    retrieve()：帮助我们完成了获取单条数据--》get，需要id
3.mixins.UpdateModelMixin：
    update()：帮助我们完成了全部更新--》put
    partial_update()：帮助我们完成了局部更新--》patch
4.mixins.DestroyModelMixin：
    destroy()：帮助我们完成了删除--》delete，需要id
5.mixins.ListModelMixin：
    list()：帮助我们完成了获取多条数据--》get
6.GenericViewSet
    View Code

    ModelViewSet自定义url

    # urls.py
from django.conf.urls import url, include
from app01 import views
​
urlpatterns = [
    url(r'^test/$', views.UserViewSet.as_view({'get': 'list', 'post': 'create'})),
    url(r'^test/(?P<pk>\d+)/$', views.UserViewSet.as_view(
        {'get': 'retrieve', 'put': 'update', 'patch': 'partial_update', 'delete': 'destroy'})),
]
    urls.py
    # views.py
from rest_framework.viewsets import ModelViewSet
from rest_framework.pagination import PageNumberPagination
from rest_framework import serializers
from app01 import models
​
class UserSerializer(serializers.ModelSerializer):
    class Meta:
        model = models.UserInfo
        fields = "__all__"
​
class UserViewSet(ModelViewSet):
    queryset = models.UserInfo.objects.all()
    serializer_class = UserSerializer
    pagination_class = PageNumberPagination
    views.py

  • 总结

    1.只完成增删改查：ModelViewSet
2.增删：CreateModelMixin，DestroyModelMixin，GenericViewSet
3.复杂逻辑：GenericViewSet，APIView
    View Code 

3.13 路由

  • 自定义路由系统

    from django.conf.urls import url, include
from app01 import views
# 4中路由方式
urlpatterns = [
    url(r'^test/$', views.TestView.as_view()),
    url(r'^test\.(?P<format>[a-z0-9]+)$', views.TestView.as_view()),
    url(r'^test/(?P<pk>[^/.]+)/$', views.TestView.as_view()),
    url(r'^test/(?P<pk>[^/.]+)\.(?P<format>[a-z0-9]+)$', views.TestView.as_view())
]
    View Code

  • 半自定义路由系统

    # urls.py
from django.conf.urls import url, include
from app01 import views
​
urlpatterns = [
    url(r'^test/$', views.UserViewSet.as_view({'get': 'list', 'post': 'create'})),
    url(r'^test/(?P<pk>\d+)/$', views.UserViewSet.as_view(
        {'get': 'retrieve', 'put': 'update', 'patch': 'partial_update', 'delete': 'destroy'})),
]
    View Code

  • 自动生成路由

    from django.conf.urls import url, include
from rest_framework import routers
from app01 import views
​
​
router = routers.DefaultRouter()
router.register(r'users', views.UserViewSet)
​
urlpatterns = [
    url(r'^', include(router.urls)),
]
    urls.py
    # views.py
from rest_framework.viewsets import ModelViewSet
from rest_framework.pagination import PageNumberPagination
from rest_framework import serializers
from app01 import models
​
class UserSerializer(serializers.ModelSerializer):
    class Meta:
        model = models.UserInfo
        fields = "__all__"
​
class UserViewSet(ModelViewSet):
    queryset = models.UserInfo.objects.all()
    serializer_class = UserSerializer
    pagination_class = PageNumberPagination
    View Code

3.14 渲染器

根据 用户请求URL 或 用户可接受的类型，筛选出合适的 渲染组件。 用户请求URL，可通过url变化来选择：

用户请求头：

  • Accept:text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,/;q=0.8

a. json格式返回数据

访问URL：

from django.conf.urls import url, include
from app01 import views
​
urlpatterns = [
    url(r'^test/$', views.TestView.as_view()),
    url(r'^test\.(?P<format>[a-z0-9]+)', views.TestView.as_view()),
]
urls.py
from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework import serializers
from rest_framework.renderers import JSONRenderer
from .. import models
​
class TestSerializer(serializers.ModelSerializer):
    class Meta:
        model = models.UserInfo
        fields = "__all__"
​
class TestView(APIView):
    # json格式
    renderer_classes = [JSONRenderer, ]
​
    def get(self, request, *args, **kwargs):
        user_list = models.UserInfo.objects.all()
        ser = TestSerializer(instance=user_list, many=True)
        return Response(ser.data)
views.py

b. 表格形式返回数据

访问URL：

from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework import serializers
from rest_framework.renderers import AdminRenderer
from .. import models
​
class TestSerializer(serializers.ModelSerializer):
    class Meta:
        model = models.UserInfo
        fields = "__all__"
​
class TestView(APIView):
    # 显示表格形式
    renderer_classes = [AdminRenderer, ]
​
    def get(self, request, *args, **kwargs):
        user_list = models.UserInfo.objects.all()
        ser = TestSerializer(instance=user_list, many=True)
        return Response(ser.data)
View Code

c. Form表单形式返回数据

访问URL：

from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework import serializers
from rest_framework.renderers import JSONRenderer
from rest_framework.renderers import AdminRenderer
from rest_framework.renderers import HTMLFormRenderer
from .. import models
​
class TestSerializer(serializers.ModelSerializer):
    class Meta:
        model = models.UserInfo
        fields = "__all__"
​
class TestView(APIView):
    # form表单形式
    renderer_classes = [HTMLFormRenderer, ]
​
    def get(self, request, *args, **kwargs):
        user_list = models.UserInfo.objects.all().first()
        ser = TestSerializer(instance=user_list, many=False)
        return Response(ser.data)
View Code

d. 自定义显示模板

访问URL：

# urls.py
from django.conf.urls import url, include
from app01 import views
​
urlpatterns = [
    url(r'^test/$', views.TestView.as_view()),
    url(r'^test\.(?P<format>[a-z0-9]+)', views.TestView.as_view()),
]
urls.py
# views.py
from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework import serializers
from rest_framework.renderers import TemplateHTMLRenderer
from .. import models
​
class TestSerializer(serializers.ModelSerializer):
    class Meta:
        model = models.UserInfo
        fields = "__all__"
​
class TestView(APIView):
    renderer_classes = [TemplateHTMLRenderer, ]
​
    def get(self, request, *args, **kwargs):
        user_list = models.UserInfo.objects.all().first()
        ser = TestSerializer(instance=user_list, many=False)
        return Response(ser.data, template_name='custom.html')
views.py
<!--custom.html--> 
​
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    {{ user }}
    {{ pwd }}
    {{ ut }}
</body>
</html>
html

e. 浏览器格式API+JSON

访问URL：

from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework import serializers
from rest_framework.renderers import JSONRenderer
from rest_framework.renderers import BrowsableAPIRenderer
from .. import models
​
class TestSerializer(serializers.ModelSerializer):
    class Meta:
        model = models.UserInfo
        fields = "__all__"
​
class CustomBrowsableAPIRenderer(BrowsableAPIRenderer):
    def get_default_renderer(self, view):
        return JSONRenderer()
​
class TestView(APIView):
    renderer_classes = [CustomBrowsableAPIRenderer, ]
​
    def get(self, request, *args, **kwargs):
        user_list = models.UserInfo.objects.all().first()
        ser = TestSerializer(instance=user_list, many=False)
        return Response(ser.data, template_name='user_detail.html')
View Code

注意：如果同时多个存在时，自动根据URL后缀来选择渲染器。

 

参考：http://www.cnblogs.com/wupeiqi/

posted @ 2019-10-28 11:48  Lowell  阅读(434)  评论(0)  编辑  收藏  举报