Django-Rest-Framework

一、什么是restful？

REST与技术无关，代表的是一种软件架构风格，REST是Representational State Transfer的简称，中文翻译为“表征状态转移”、
REST从资源的角度类审视整个网络，它将分布在网络中某个节点的资源通过URL进行标识，客户端应用通过URL来获取资源的表征，获得这些表征致使这些应用转变状态
所有的数据，不过是通过网络获取的还是操作（增删改查）的数据，都是资源，将一切数据视为资源是REST区别与其他架构风格的最本质属性
对于REST这种面向资源的架构风格，有人提出一种全新的结构理念，即：面向资源架构（ROA：Resource Oriented Architecture）

二、restful API设计（规范）

一、API与用户的通信协议，总是使用HTTPS协议
二、域名
    https:api.zhangjianping.com     尽量将API部署在专用的域名（不存在跨域问题）
    https:zhangjianping.org/api      简单的API
三、版本
    URL:   https:api.zhangjianping.com/v1
    请求头           跨域时，引发发送多次请求
四、路径，网络上的东西都是资源，均使用名词去表示
五、method
    GET：从服务器取出资源（一项或者是多项）
    POST：在服务器新建一个资源
    PUT：在服务器更新资源（客户端提供改变后的完整资源）
    PATCH：在服务器更新资源（客户端提供改变的属性）
    DELETE：从服务器删除资源
六、过滤
    通过在url上传参的形式传递搜索条件
七、状态码
八、错误处理
九、返回结果
十、Hypermedia API，RESTful API最好做到Hypermedia，即返回结果中提供链接，连向其他API方法，使得用户不查文档，也知道下一步应该做什么。

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 - [*]：服务器发生错误，用户将无法判断发出的请求是否成功。

更多看这里：http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html

状态码附录

三、基于Django实现

路由系统：

urlpatterns = [
    url(r'^admin/', admin.site.urls),
    url(r'^users/$',views.User.as_view()),
]

CBV视图：

from django.http import JsonResponse
from django.views import View
class User(View):
    def get(self,request,*args,**kwargs):
        result = {
            "status":True,
            "data":"response data"
        }
        return JsonResponse(result,status=200)
    def post(self,request,*args,**kwargs):
        result = {
            "status":True,
            "data":"response data"
        }
        return JsonResponse(result,status=200)

四、基于Django-Rest-Framework框架实现

1、基本流程

路由系统：

from django.conf.urls import url
from django.contrib import admin
from app01 import views

urlpatterns = [
    url(r'^test/$',views.TestView.as_view())
]

CBV视图：

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

class TestView(APIView):
    def dispath(self,request,*args,**kwargs):
　　　　"""请求到来之后，都要执行dispatch方法，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请求，响应内容")

以上这段代码就是rest framework框架的基本流程，重要的功能都是在APIView中的dispatch中触发的

当你运行上段代码会报错：

你使用的是restframework，但是模板用的却是Django的，所以报错在所难免，解决的办法就是在配置文件中注册

2、认证和授权

路由系统

from django.conf.urls import url
from django.contrib import admin
from app01 import views

urlpatterns = [
    url(r'^test/$',views.TestView.as_view())
]

CBV视图：

from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework.authentication import BaseAuthentication
from rest_framework.request import Request
from rest_framework import exceptions

token_list = [
    "zhangjianping",           #可以授权的数据
]

class TestAuthentication(BaseAuthentication):
    def authenticate(self, request):
        '''
        用户认证，认证成功后返回元组
        :param request:
        :return:
        '''
        val = request.query_params.get("token")    #get请求从网址栏获取到的数据
        if val not in token_list:                  #判断当前url是否可以授权访问
            raise exceptions.AuthenticationFailed("用户认证失败")
        return ("登录用户，","用户token")
    def authenticate_header(self, request):
        pass


class TestView(APIView):
    '''
    调用这个函数的时候，会自动触发authentication_classes的运行，所以会先执行上边的类
    '''
    authentication_classes = [TestAuthentication,]
    permission_classes = []


    def get(self,request,*args,**kwargs):
        print("====request.user====",request.user)         #当前登录的用户
        print("====request.auth====",request.auth)         #获取到的用户token
        return Response("GET请求，响应内容")

    def post(self,request,*args,**kwargs):
        return Response("POST请求，响应内容")

    def put(self,request,*args,**kwargs):
        return Response("PUT请求，响应内容")

3、用户登录

路由系统：

from django.conf.urls import url
from django.contrib import admin
from app01 import views

urlpatterns = [
　　url(r'^auth/$',views.AuthView.as_view()),
]

model表操作：

from django.db import models

class UserInfo(models.Model):
    username = models.CharField(max_length=16)
    password = models.CharField(max_length=16)
    token = models.CharField(max_length=64,null=True)

CBV视图：

from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework.authentication import BaseAuthentication
from rest_framework.request import Request
from rest_framework import exceptions
import time,hashlib
from app01 import models

class AuthView(APIView):
    authentication_classes = []
    def get(self,request):
        ret = {"code":1000,"msg":None}
        user = request.query_params.get("user")
        pwd = request.query_params.get("pwd")
        obj = models.UserInfo.objects.filter(username=user,password=pwd).first()
        if not obj:    #如果没有获取到用户信息执行
            ret["code"] = 1001
            ret["msg"] = "用户名或密码错误"
            return Response(ret)
        ctime = time.time()   #得到一个时间戳
        key = "%s|%s"%(user,ctime)    #类似于加密盐
        m = hashlib.md5()
        m.update(key.encode("utf-8"))
        token = m.hexdigest()        #token经过MD5加密处理
        obj.token = token            #数据库的空字符串，颁发授权信息
        ret["token"] = token         #写入数据表
        return Response(ret)

4、限制访问频率

路由系统

from django.conf.urls import url
from django.contrib import admin
from app01 import views
from app02 import views as app02_view
from app03 import views as app03_view
urlpatterns = [
rl(r'^salary/', app02_view.SalaryView.as_view()),
    url(r'^limit/', app03_view.LimitView.as_view()),
]

#配置文件
REST_FRAMEWORK = {
    'UNAUTHENTICATED_USER': None,
    'UNAUTHENTICATED_TOKEN': None,
    "DEFAULT_AUTHENTICATION_CLASSES": [
        # "app02.utils.MyAuthentication",
    ],
    'DEFAULT_PERMISSION_CLASSES':[

    ],
    'DEFAULT_THROTTLE_RATES':{
        'wdp':'2/minute'           #每分钟两次
    }
}

CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.filebased.FileBasedCache',
        'LOCATION': 'cache',        数据默认报错在缓存
    }
}

#生写，自己实现            -----CBV视图
from django.shortcuts import render
from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework.throttling import BaseThrottle,SimpleRateThrottle

from rest_framework import exceptions

RECORD = {

}
class MyThrottle(BaseThrottle):
    def allow_request(self,request,view):
        """
        # 返回False，限制
        # 返回True，通行
        :param request: 
        :param view: 
        :return: 
        """
        """
         a. 对匿名用户进行限制：每个用户1分钟允许访问10次
            - 获取用户IP request 1.1.1.1
        """
        import time
        ctime = time.time()          #获取当前时间
        ip = self.get_ident(request)        #获取IP
        if ip not in RECORD:         #IP没有在新建的那个字典
            RECORD[ip] = [ctime,]    #将当前的IP作为key，时间作为value列表
        else:
            # [4507862389234,3507862389234,2507862389234,1507862389234,]
            time_list = RECORD[ip]         #如果在的话获取IP时间列表
            while True:
                val = time_list[-1]        #取出最后一个值
                if (ctime-60) > val:       #如果当前的时间-60秒>取出的最后一个值
                    time_list.pop()        #就将这个值取出来
                else:
                    break
            if len(time_list) > 10:    #一分钟访问次数超过10次，return False
                return False
            time_list.insert(0,ctime)    #将当前时间插入到第一个位置
        return True
    def wait(self,request):
        """
        :return: 返回需要等待的时间
        """
        import time
        ctime = time.time()
        first_in_time = RECORD[self.get_ident(request)][-1]
        wt = 60 - (ctime - first_in_time)      #等待的时间
        return wt

class LimitView(APIView):
    authentication_classes = []
    permission_classes = []
    throttle_classes=[MyThrottle,]
    def get(self,request,*args,**kwargs):
        # self.dispatch
        return Response('控制访问频率示例')

    def throttled(self, request, wait):
        """
        If request is throttled, determine what kind of exception to raise.
        """

        class MyThrottled(exceptions.Throttled):
            default_detail = '请求被限制.'
            extra_detail_singular = 'Expected available in {wait} second.'
            extra_detail_plural = '还需要再等待{wait}'

        raise MyThrottled(wait)

CBV路由系统

class MySimpleRateThrottle(SimpleRateThrottle):
    scope = "wdp"

    def get_cache_key(self, request, view):
        return self.get_ident(request)
class LimitView(APIView):
    authentication_classes = []
    permission_classes = []
    throttle_classes=[MySimpleRateThrottle,]
    def get(self,request,*args,**kwargs):
        # self.dispatch
        return Response('控制访问频率示例')

    def throttled(self, request, wait):
        """
        If request is throttled, determine what kind of exception to raise.
        """

        class MyThrottled(exceptions.Throttled):
            default_detail = '请求被限制.'
            extra_detail_singular = 'Expected available in {wait} second.'
            extra_detail_plural = '还需要再等待{wait}'

        raise MyThrottled(wait)

认证、权限+访问控制的实现

from django.conf.urls import url
from django.contrib import admin
from app04 import views as app04_view

urlpatterns = [
    url(r'^index/', app04_view.IndexView.as_view()),
    url(r'^manage/', app04_view.ManageView.as_view()),
]

setting配置

REST_FRAMEWORK = {
    'UNAUTHENTICATED_USER': None,
    'UNAUTHENTICATED_TOKEN': None,
    "DEFAULT_AUTHENTICATION_CLASSES": [    #认证控制
        # "app02.utils.MyAuthentication",
    ],
    'DEFAULT_PERMISSION_CLASSES':[     #权限控制

    ],
    'DEFAULT_THROTTLE_RATES':{
        'wdp_anon':'5/minute',       #匿名用户配置
        'wdp_user':'10/minute',      #正常用户配置

    }
}

CACHES = {                        #缓存配置
    'default': {
        'BACKEND': 'django.core.cache.backends.filebased.FileBasedCache',
        'LOCATION': 'cache',
    }
}

CBV视图

from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework.throttling import BaseThrottle,SimpleRateThrottle
from rest_framework.authentication import BaseAuthentication
from app02 import models

class MyAuthentication(BaseAuthentication):
    """
    用户认证类，获取url传过来的数据
    """
    def authenticate(self, request):
        token = request.query_params.get('token')
        obj = models.UserInfo.objects.filter(token=token).first()
        if obj:
            return (obj.username,obj)
        return None

    def authenticate_header(self, request):
        pass

class MyPermission(object):
    message = "无权访问"
    def has_permission(self,request,view):
        if request.user:
            return True
        return False

class AdminPermission(object):
    message = "无权访问"
    def has_permission(self,request,view):
        if request.user == 'alex':
            return True
        return False


class AnonThrottle(SimpleRateThrottle):
    """
    针对匿名用户的配置
    """
    scope = "wdp_anon"      #配置文件中的值
 
    def get_cache_key(self, request, view):
        # 返回None，表示我不限制
        # 登录用户我不管
        if request.user:          #正常登陆的用户不做限制
            return None
        # 匿名用户                #匿名用户做限制
        return self.get_ident(request)

class UserThrottle(SimpleRateThrottle):
    """
    针对已经登陆的用户所做的配置
    """
    scope = "wdp_user"     #配置文件获取

    def get_cache_key(self, request, view):
        # 登录用户
        if request.user:
            return request.user
        # 匿名用户我不管
        return None


# 无需登录就可以访问
class IndexView(APIView):
    authentication_classes = [MyAuthentication,]          #用户认证
    permission_classes = []                               #无需登陆就可以访问的页面不需要权限的控制
    throttle_classes=[AnonThrottle,UserThrottle,]         #限流
    def get(self,request,*args,**kwargs):
        # self.dispatch
        return Response('无需登陆访问首页')

　　def throttled(self, request, wait):
　　　　"""自定义返回的文本信息"""
   　　class MyThrottled(exceptions.Throttled):
      　　default_detail = '请求被限制.'
      　　extra_detail_singular = 'Expected available in {wait} second.'
      　　extra_detail_plural = '还需要再等待{wait}'
   　　raise MyThrottled(wait)



# 需登录就可以访问
class ManageView(APIView):
    authentication_classes = [MyAuthentication,]
    permission_classes = [MyPermission,]                #需要登陆访问的页面做了权限的控制
    throttle_classes=[AnonThrottle,UserThrottle,]
    def get(self,request,*args,**kwargs):
        # self.dispatch
        return Response('需要登陆访问首页')

5、版本限制

URL做版本限制

urlpatterns = [
    url(r'^api/(?P<version>[v1|v2]+)/', include('api.urls')),
            ]
urlpatterns = [
     url(r'^users/', views.UsersView.as_view(),name='u'),
            ]

class UsersView(APIView):
    # 基于url传参
    # versioning_class = QueryParameterVersioning             get视图中直接采用request.version就可以取值
    # 基于URL http://127.0.0.1:8001/api/v2/users/
    # versioning_class = URLPathVersioning
    # 基于子域名 http://v1.luffy.com/users/
    # versioning_class = HostNameVersioning
    #上边的这些配置是基于局部配置，用的更多的是全局的配置，所以只介绍全局配置　　


    def get(self,request,*args,**kwargs):
        self.dispatch
        print(request.version) # QueryParameterVersioning().detemiin_version()
        print(request.versioning_scheme) # QueryParameterVersioning()

        # 当前版本一样的URL
        url = request.versioning_scheme.reverse(viewname='u',request=request)
        print(url)

        # 当前版本不一样的URL
        from django.urls import reverse
        url = reverse(viewname='u',kwargs={'version':'v2'})
        print(url)
        return Response('...')

REST_FRAMEWORK = {
        'VERSION_PARAM':'version',          #固定的名字
        'DEFAULT_VERSION':'v1',              #默认版本号
        'ALLOWED_VERSIONS':['v1','v2'],       #可以使用的版本号
        'DEFAULT_VERSIONING_CLASS':"rest_framework.versioning.URLPathVersioning"     #版本由url控制
            }

hostname做版本控制

urlpatterns = [
     url(r'^api/', include('api.urls')),
            ]
urlpatterns = [
     url(r'^users/', views.UsersView.as_view(),name='u'),
            ]

class UsersView(APIView):
     def get(self,request,*args,**kwargs):
         self.dispatch
         print(request.version) # QueryParameterVersioning().detemiin_version()
         print(request.versioning_scheme) # QueryParameterVersioning()

REST_FRAMEWORK = {
    'VERSION_PARAM':'version',
    'DEFAULT_VERSION':'v1',
    'ALLOWED_VERSIONS':['v1','v2'],
                'DEFAULT_VERSIONING_CLASS':"rest_framework.versioning.HostNameVersioning"     #根据域名做版本控制
            }
根据hostname做版本限制需要配置域名，这里我们直接修改电脑的host文件做测试（Windows系统的 C:\Windows\System32\drivers\etc；mac本或者Linux的在
# vim /etc/hosts）
直接做以下配置：
            127.0.0.1    v1.qqq.com
            127.0.0.1    v2.qqq.com

6、解析器

请求的数据进行解析：请求体进行解析。表示服务端可以解析的数据格式的种类。
     Content-Type: application/url-encoding.....
     request.body
     request.POST
            
     Content-Type: application/json.....
     request.body
     request.POST
假如客户端发送的数据是：
     Content-Type: application/json
     '{"name":"alex","age":123}'
那么服务端接受的是：
　　　　读取客户端发送的Content-Type的值 application/json
       parser_classes = [JSONParser,]
       media_type_list = ['application/json',]
        
       如果客户端的Content-Type的值和 application/json 匹配：JSONParser处理数据
       如果客户端的Content-Type的值和 application/x-www-form-urlencoded 匹配：FormParser处理数据

单视图：
class UsersView(APIView):
     parser_classes = [JSONParser,]
                
全局配置：
REST_FRAMEWORK = {
    'VERSION_PARAM':'version',
    'DEFAULT_VERSION':'v1',
    'ALLOWED_VERSIONS':['v1','v2'],
    # 'DEFAULT_VERSIONING_CLASS':"rest_framework.versioning.HostNameVersioning"
    'DEFAULT_VERSIONING_CLASS':"rest_framework.versioning.URLPathVersioning",
    'DEFAULT_PARSER_CLASSES':[
              'rest_framework.parsers.JSONParser',            #解析jsonparser
              'rest_framework.parsers.FormParser',            #解析formparser
                    ]
                }

7、序列化操作

#需要导入的包和模块
from django.shortcuts import render
from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework.authentication import BasicAuthentication
from rest_framework.versioning import QueryParameterVersioning,URLPathVersioning,HostNameVersioning
from rest_framework.renderers import BrowsableAPIRenderer,JSONRenderer
from rest_framework.parsers import JSONParser,FormParser
from rest_framework.request import Request
from rest_framework import serializers
from . import models                    #数据表

数据库表

from django.db import models

# Create your models here.

class Menu(models.Model):
    name = models.CharField(max_length=32)

class Group(models.Model):
    title = models.CharField(max_length=32)
    mu = models.ForeignKey(to="Menu",default=1)

class UserInfo(models.Model):
    name = models.CharField(max_length=32)
    pwd = models.CharField(max_length=32)

    group = models.ForeignKey(to='Group')
    roles = models.ManyToManyField(to='Role')


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

a、基本操作

class UsersSerializer(serializers.Serializer):
    name = serializers.CharField()
    pwd = serializers.CharField()

class UsersView(APIView):
    def get(self,request,*args,**kwargs):
        self.dispatch
        # 方式一：
        # user_list = models.UserInfo.objects.all().values('name','pwd','group__id',"group__title")
        # return Response(user_list)

        # 方式二之多对象
        # user_list = models.UserInfo.objects.all()
        # ser = UsersSerializer(instance=user_list,many=True)
        # return Response(ser.data)

        # 方式二之单对象
        user = models.UserInfo.objects.all().first()
        ser = UsersSerializer(instance=user, many=False)
        return Response(ser.data)

b、跨表操作

class UsersSerializer(serializers.Serializer):
    name = serializers.CharField()
    pwd = serializers.CharField()
    group_id = serializers.CharField()
    xxxx = serializers.CharField(source="group.title")
    x1 = serializers.CharField(source="group.mu.name")


class UsersView(APIView):
    def get(self,request,*args,**kwargs):
        self.dispatch
        # 方式一：
        # user_list = models.UserInfo.objects.all().values('name','pwd','group__id',"group__title")
        # return Response(user_list)

        # 方式二之多对象
        user_list = models.UserInfo.objects.all()
        ser = UsersSerializer(instance=user_list,many=True)
        return Response(ser.data)

c、复杂的序列化

操作一

class MyCharField(serializers.CharField):
    def to_representation(self, value):
        data_list = []
        for row in value:
            data_list.append(row.name)
        return data_list

class UsersSerializer(serializers.Serializer):
    name = serializers.CharField() # obj.name
    pwd = serializers.CharField()  # obj.pwd
    group_id = serializers.CharField() # obj.group_id
    xxxx = serializers.CharField(source="group.title") # obj.group.title
    x1 = serializers.CharField(source="group.mu.name") # obj.mu.name
    # x2 = serializers.CharField(source="roles.all") # obj.mu.name
    x2 = MyCharField(source="roles.all") # obj.mu.name

操作二

class MyCharField(serializers.CharField):
    def to_representation(self, value):
        return {'id':value.pk, 'name':value.name}

class UsersSerializer(serializers.Serializer):
    name = serializers.CharField() # obj.name
    pwd = serializers.CharField()  # obj.pwd
    group_id = serializers.CharField() # obj.group_id
    xxxx = serializers.CharField(source="group.title") # obj.group.title
    x1 = serializers.CharField(source="group.mu.name") # obj.mu.name
    # x2 = serializers.CharField(source="roles.all") # obj.mu.name
    x2 = serializers.ListField(child=MyCharField(),source="roles.all") # obj.mu.name

操作三

class UsersSerializer(serializers.Serializer):
    name = serializers.CharField() # obj.name
    pwd = serializers.CharField()  # obj.pwd
    group_id = serializers.CharField() # obj.group_id
    xxxx = serializers.CharField(source="group.title") # obj.group.title
    x1 = serializers.CharField(source="group.mu.name") # obj.mu.name
    # x2 = serializers.CharField(source="roles.all") # obj.mu.name
    # x2 = serializers.ListField(child=MyCharField(),source="roles.all") # obj.mu.name
    x2 = serializers.SerializerMethodField()

    def get_x2(self,obj):
        obj.roles.all()
        role_list = obj.roles.filter(id__gt=1)
        data_list = []
        for row in role_list:
            data_list.append({'pk':row.pk,'name':row.name})
        return data_list

以上三种方式都是使用相同的视图

class UsersView(APIView):
    def get(self,request,*args,**kwargs):
        self.dispatch
        # 方式一：
        # user_list = models.UserInfo.objects.all().values('name','pwd','group__id',"group__title")
        # return Response(user_list)

        # 方式二之多对象
        user_list = models.UserInfo.objects.all()
        # [obj1,obj2,obj3]
        ser = UsersSerializer(instance=user_list,many=True)
        return Response(ser.data)

d、基于model

class UsersSerializer(serializers.ModelSerializer):
    class Meta:
        model = models.UserInfo
        fields = "__all__"
        # fields = ['name', 'pwd','group']
        depth = 1


class UsersView(APIView):
    def get(self,request,*args,**kwargs):
        self.dispatch
        # 方式一：
        # user_list = models.UserInfo.objects.all().values('name','pwd','group__id',"group__title")
        # return Response(user_list)

        # 方式二之多对象
        user_list = models.UserInfo.objects.all()
        # [obj1,obj2,obj3]
        ser = UsersSerializer(instance=user_list,many=True)
        return Response(ser.data)

e、生成url

class UsersSerializer(serializers.ModelSerializer):
    group = serializers.HyperlinkedIdentityField(view_name='detail')
    class Meta:
        model = models.UserInfo
        fields = "__all__"
        fields = ['name', 'pwd','group']
        depth = 1


class UsersView(APIView):
    def get(self,request,*args,**kwargs):
        self.dispatch
        # 方式一：
        # user_list = models.UserInfo.objects.all().values('name','pwd','group__id',"group__title")
        # return Response(user_list)

        # 方式二之多对象
        user_list = models.UserInfo.objects.all()
        # [obj1,obj2,obj3]
        ser = UsersSerializer(instance=user_list,many=True,context={'request':request})
        return Response(ser.data)

f、全局生成url

class UsersSerializer(serializers.HyperlinkedModelSerializer):
    class Meta:
        model = models.UserInfo
        fields = "__all__"

        # fields = ['id','name','pwd']

class UsersView(APIView):
    def get(self,request,*args,**kwargs):
        self.dispatch
        # 方式一：
        # user_list = models.UserInfo.objects.all().values('name','pwd','group__id',"group__title")
        # return Response(user_list)

        # 方式二之多对象
        user_list = models.UserInfo.objects.all()
        # [obj1,obj2,obj3]
        ser = UsersSerializer(instance=user_list,many=True,context={'request':request})
        return Response(ser.data)

请求数据验证

方式一

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

    def __call__(self, value):
        if value != self.base:
            message = '用户输入的值必须是 %s.' % self.base
            raise serializers.ValidationError(message)

    def set_context(self, serializer_field):
        """
        This hook is called by the serializer instance,
        prior to the validation call being made.
        """
        # 执行验证之前调用,serializer_fields是当前字段对象
        pass

class UsersSerializer(serializers.Serializer):
        name = serializers.CharField(min_length=6)
        pwd = serializers.CharField(error_messages={'required': '密码不能为空'}, validators=[PasswordValidator('666')])

方式二

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

    def __call__(self, value):
        if value != self.base:
            message = '用户输入的值必须是 %s.' % self.base
            raise serializers.ValidationError(message)

    def set_context(self, serializer_field):
        """
        This hook is called by the serializer instance,
        prior to the validation call being made.
        """
        # 执行验证之前调用,serializer_fields是当前字段对象
        pass

class UsersSerializer(serializers.ModelSerializer):
    class Meta:
        model = models.UserInfo
        fields = "__all__"
        extra_kwargs = {
            'name': {'min_length': 6},
            'pwd': {'validators': [PasswordValidator(666), ]}
        }

使用：

class UsersView(APIView):
    def get(self,request,*args,**kwargs):
        self.dispatch
        # 方式一：
        # user_list = models.UserInfo.objects.all().values('name','pwd','group__id',"group__title")
        # return Response(user_list)

        # 方式二之多对象
        user_list = models.UserInfo.objects.all()
        # [obj1,obj2,obj3]
        ser = UsersSerializer(instance=user_list,many=True,context={'request':request})
        return Response(ser.data)

    def post(self,request,*args,**kwargs):
        ser = UsersSerializer(data=request.data)
        if ser.is_valid():
            print(ser.validated_data)
        else:
            print(ser.errors)
        return Response('...')

8、分页

a、基于limitoffsetpagination做分页

class P1(LimitOffsetPagination):
    max_limit = 3
    default_limit = 2
    limit_query_param = 'limit'
    offset_query_param = 'offset'

b、基于PageNumberPagination做分页

class P2(PageNumberPagination):
    # 每页显示的数据条数
    max_page_size = 5
    page_size = 2
    page_size_query_param = 'size'
    # 页码
    page_query_param = 'page'

c、基于CursorPagination做分页

class P3(CursorPagination):
    cursor_query_param = 'cursor'
    page_size = 2
    ordering = 'id'

需要用到的模块

from django.shortcuts import render
from rest_framework import views
from rest_framework.response import Response
from rest_framework.pagination import LimitOffsetPagination,PageNumberPagination,CursorPagination
from api import models
from api.serializers.index import IndexSerializer

基于视图实现

class IndexView(views.APIView):
    def get(self,request,*args,**kwargs):
        user_list = models.UserInfo.objects.all()            #查询到所有的数据
        p1 = P1()                                            #实例化显示的那个对象
        page_user_list = p1.paginate_queryset(queryset=user_list, request=request, view=self)     #经过处理后的数据列表
        ser = IndexSerializer(instance=page_user_list, many=True)       
        return Response(ser.data) # 不含上一页和下一页                 
        # return p1.get_paginated_response(ser.data) # 含上一页和下一页

基于视图使用对象的方式实现

class BaseResponse(object):
    def __init__(self,code=1000,data=None,error=None):
        self.code = code
        self.data = data
        self.error = error
class IndexView(views.APIView):
    def get(self,request,*args,**kwargs):
        ret = BaseResponse()              #基于对象的形式展示
        try:
            user_list = models.UserInfo.objects.all()
            p1 = P1()
            page_user_list = p1.paginate_queryset(queryset=user_list,request=request,view=self)
            ser = IndexSerializer(instance=page_user_list,many=True)
            ret.data = ser.data         #给对象赋值
            ret.next = p1.get_next_link()      #上一页下一页链接
        except Exception as e:
            ret.code= 1001
            ret.error = 'xxxx错误'
        return Response(ret.__dict__)           #以字典的形式返回

9、视图

1. APIView

class IndexView(views.APIView):
    def get(self, request, *args, **kwargs):
        user_list = models.UserInfo.objects.all()
        ser = IndexSerializer(instance=user_list,many=True)
        return Response(ser.data)

2.GenericAPIView

class IndexView(generics.GenericAPIView):
    queryset = models.UserInfo.objects.all()
    serializer_class = IndexSerializer
    pagination_class = P2
    def get(self,request,*args,**kwargs):
        user_list = self.get_queryset()
        p1 = self.paginator
        data = p1.paginate_queryset(queryset=user_list,request=request,view=self)
        ser = self.get_serializer(instance=data,many=True)
        return p1.get_paginated_response(ser.data)

3. GenericViewSet(ViewSetMixin, generics.GenericAPIView)

路由修改
urlpatterns = [
                url(r'^index/$', views.IndexView.as_view({'get':'list','post':'create'})),]
                
from rest_framework.viewsets import GenericViewSet
class IndexView(GenericViewSet):
    queryset = models.UserInfo.objects.all()
    serializer_class = IndexSerializer
    pagination_class = P2
    def list(self,request,*args,**kwargs):
        print("这里是list请求")
        return Response("...")
    def retrieve(self,request,*args,**kwargs):
        print("这里是post请求")
        return Response("...")
    def create(self,request,*args,**kwargs):
        print("这里是put请求")
        return Response("...")
        




自定义：

    增
        POST
        /users/
    删
        DELETE
        /users/1/
    改
        PUT
        /users/1/
        
        patch
        /users/1/
    查
        GET
        /users/ 
        GET
        /users/1/
                            
urlpatterns = [
    url(r'^index/$', views.IndexView.as_view()),
    url(r'^index/(?P<pk>\d+)$', views.IndexView.as_view({'get':'retrieve'})),
]
                            
class IndexView(views.APIView):

    def get(self,request,*args,**kwargs):
        pk = kwargs.get('pk')
        if pk:
            pass # 获取单条信息
        else:
            pass # 获取列表信息

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

    def put(self,request,*args,**kwargs):
        pass

    def patch(self,request,*args,**kwargs):
        pass

    def delete(self,request,*args,**kwargs):
        pass

4.ModelViewSet

ModelViewSet(mixins.CreateModelMixin,
            mixins.RetrieveModelMixin,
            mixins.UpdateModelMixin,
            mixins.DestroyModelMixin,
            mixins.ListModelMixin,
            GenericViewSet)    
视图：
urlpatterns = [
    url(r'^user/$',views.IndexView.as_view({"get":"list","post":"create"})),
    url(r'^user/(?P<pk>\d+)/$',views.IndexView.as_view({"get":"retrieve","delete":"destroy","put":"update","patch":"partial_update"}))
]
from rest_framework.viewsets import ModelViewSet

class IndexView(ModelViewSet):
    queryset = models.UserInfo.objects.all()
    serializer_class = IndexSerializer
    pagination_class = P2

10、路由和渲染器

第一类：
    # http://127.0.0.1:8000/api/v1/auth/
    url(r'^auth/$', views.AuthView.as_view()),
    # http://127.0.0.1:8000/api/v1/auth.json # 想要让页面显示json格式
    url(r'^auth\.(?P<format>[a-z0-9]+)$', views.AuthView.as_view()),
    # http://127.0.0.1:8000/api/v1/auth/1/
    url(r'^auth/(?P<pk>\d+)/$', views.AuthView.as_view()),
    # http://127.0.0.1:8000/api/v1/auth/1.json
    url(r'^auth/(?P<pk>\d+)\.(?P<format>[a-z0-9]+)$', views.AuthView.as_view()),
    class AuthView(views.APIView):

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

第二类：
    url(r'^index/$', views.IndexView.as_view({'get':'list','post':'create'})),
    url(r'^index/\.(?P<format>[a-z0-9]+)$', views.IndexView.as_view({'get':'list','post':'create'})),
    url(r'^index/(?P<pk>\d+)/$', views.IndexView.as_view({'get':'retrieve','delete':'destroy','put':'update','patch':'partial_update'})),
    url(r'^index/(?P<pk>\d+)\.(?P<format>[a-z0-9]+)$', views.IndexView.as_view({'get':'retrieve','delete':'destroy','put':'update','patch':'partial_update'})),

    class IndexView(viewsets.ModelViewSet):
        queryset = models.UserInfo.objects.all()
        serializer_class = IndexSerializer
        pagination_class = P2

第三类： 
    router = DefaultRouter()
    router.register('index',views.IndexViewSet)
    urlpatterns = [
        url(r'^', include(router.urls)),
    ]
    
    
    class IndexViewSet(viewsets.ModelViewSet):
        queryset = models.UserInfo.objects.all()
        serializer_class = IndexSerializer
        pagination_class = P2
        
        
        
    class IndexSerializer(serializers.ModelSerializer):
        class Meta:
            model = models.UserInfo
            fields = "__all__"

.渲染器
renderer_classes = [JSONRenderer,BrowsableAPIRenderer]     #好看的页面默认返回的是这两个，如果只想返回json则    JSONRenderer

给query_set 新增一个扩展字段，并按照扩展字段进行排序（需要更新serializer，不需要更新model）

类继承顺序

未完待续。。。。

posted @ 2018-02-05 14:34 一石数字欠我15w!!! 阅读(700) 评论(0) 编辑收藏举报

刷新页面返回顶部

一石数字欠我15W❗

抖音搜索“一石数字”！第一个就是我；打工人不是牛马！ “维权”到底！

Django-Rest-Framework

一、什么是restful？

二、restful API设计（规范）

三、基于Django实现

四、基于Django-Rest-Framework框架实现

1、基本流程

2、认证和授权

3、用户登录

4、限制访问频率

认证、权限+访问控制的实现

setting配置

CBV视图

5、版本限制

URL做版本限制

hostname做版本控制

6、解析器

7、序列化操作

数据库表

a、基本操作

b、跨表操作

c、复杂的序列化

d、基于model

e、生成url

f、全局生成url

请求数据验证

8、分页

a、基于limitoffsetpagination做分页

b、基于PageNumberPagination做分页

c、基于CursorPagination做分页

9、视图

1. APIView

2.GenericAPIView

3. GenericViewSet(ViewSetMixin, generics.GenericAPIView)

4.ModelViewSet

10、路由和渲染器

未完待续。。。。

公告

一石数字欠我15W❗

抖音搜索“一石数字”！第一个就是我； 打工人不是牛马！ “维权”到底！

Django-Rest-Framework

一、什么是restful？

二、restful API设计（规范）

三、基于Django实现

四、基于Django-Rest-Framework框架实现

1、基本流程

2、认证和授权

3、用户登录

4、限制访问频率

认证、权限+访问控制的实现

setting配置

CBV视图

5、版本限制

URL做版本限制

hostname做版本控制

6、解析器

7、序列化操作

数据库表

a、基本操作

b、跨表操作

c、复杂的序列化

d、基于model

e、生成url

f、全局生成url

请求数据验证

8、分页

a、基于limitoffsetpagination做分页

b、基于PageNumberPagination做分页

c、基于CursorPagination做分页

9、视图

1. APIView

2.GenericAPIView

3. GenericViewSet(ViewSetMixin, generics.GenericAPIView)

4.ModelViewSet

10、路由和渲染器

未完待续。。。。

公告

抖音搜索“一石数字”！第一个就是我；打工人不是牛马！ “维权”到底！