Restful Framework （三）

2023-01-06 11:36:48

一、版本

程序也来越大时，可能通过版本不同做不同的处理

没用rest_framework之前，我们可以通过以下这样的方式去获取。

 class UserView(APIView):

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

         version = request.query_params.get('version')

         print(version)

         if version=='v1':

             #如果版本是v1

             ret = {

                 'code':111,

                 'msg':'版本一的内容'

             }

         elif version=='v2':

             # 如果是v2

             ret = {

                 'code': 112,

                 'msg': '版本二的内容'

             }

         else:

             ret = {

                 'code': 0,

                 'msg': '不支持其他版本'

             }

         return Response(ret)

现在我们来用rest_framework实现一下，有两种方式

1、基于url的方式

 #基于url传参的形式

     versioning_class = QueryParameterVersioning

    #http://127.0.0.1:8080/api/users/?version=v2

#基于url的形式

　　versioning_class = URLPathVersioning

　　#http://127.0.0.1:8080/api/v1/users/

具体步骤

 REST_FRAMEWORK = {

     'DEFAULT_VERSION': 'v1',  #默认的版本

     'ALLOWED_VERSIONS': ['v1','v2'],  #允许的版本

     'VERSION_PARAM': 'version',

 }

1、配置

 from django.conf.urls import url,include

 from django.contrib import admin

 urlpatterns = [

     url(r'^admin/', admin.site.urls),

     url(r'^api/(?P<version>[v1|v2]+)/', include('api.urls'), name='users-list'),

 ]

urls.py

 from api import views

 urlpatterns = [

     # url(r'^users/', views.UserView.as_view()),

     url(r'^users/', views.UserView1.as_view()),

 ]

urls.py

 class UserView1(APIView):

     #基于url传参的形式

     # versioning_class = QueryParameterVersioning

     #http://127.0.0.1:8080/api/users/?version=v2

     #基于url的形式

     #http://127.0.0.1:8080/api/v1/users/

     versioning_class = URLPathVersioning

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

         # self.dispatch

         print(request.version)  #打印的是版本

         print(request.versioning_scheme)  #打印的是对象

         if request.version=='v2':

             return Response('我是版本二')

         elif request.version=='v1':

             return Response('我是版本一')

         else:

             return Response('去去去')

views.py

注：在配置的时候

REST_FRAMEWORK = {

                'VERSION_PARAM':'version',

                'DEFAULT_VERSION':'v1',

                'ALLOWED_VERSIONS':['v1','v2'],

                # 'DEFAULT_VERSIONING_CLASS':"rest_framework.versioning.HostNameVersioning" 
 　　　　　　　　　　#如果加上这个配置就不用versioning_class = QueryParameterVersioning这样在指定了，

　　　　　　　　　　 'DEFAULT_VERSIONING_CLASS':"rest_framework.versioning.URLPathVersioning" }

附加：restful提供的反向生成

#http://127.0.0.1:8080/api/v1/users/

 #urls.py

 #分发路由

 urlpatterns = [

     url(r'^admin/', admin.site.urls),

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

 ]

 #api.urls.py

 urlpatterns = [

     url(r'^users/', views.UserView1.as_view(), name='users-list'),

 ]

 #views.py

 导入类

 from rest_framework.reverse import reverse

 url = request.versioning_scheme.reverse(viewname='users-list',request=request)

         print(url)

restfoamework反向解析

我们自己用django实现的，当前版本不一样的时候可以用这种方式

 from django.urls import reverse

        url = reverse(viewname='users-list',kwargs={'version':'v2'}) #指定的是v2就是v2，当你路径中输入v1的时候还是v2的路径

        print(url) #/api/v2/users/

2、基于子域名传参

 #分发url

             urlpatterns = [

                 #url(r'^admin/', admin.site.urls),

                 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"

             }

             # C:\Windows\System32\drivers\etc

             # vim /etc/hosts

             127.0.0.1    v1.luffy.com

             127.0.0.1    v2.luffy.com

             #配置ALLOWED_HOSTS = ['*']

基于子域名传参

如果遇到这样的错误

这是由于没有允许，解决办法，在settings里面配置一下

ALLOWED_HOSTS = ['*']

二、解析器：reqest.data取值的时候才执行

回到顶部

对请求的数据进行解析：是针对请求体进行解析的。表示服务器可以解析的数据格式的种类

django中的发送请求

#如果是这样的格式发送的数据，在POST里面有值

Content-Type: application/url-encoding.....

    request.body

    request.POST

#如果是发送的json的格式，在POST里面是没有值的，在body里面有值，可通过decode,然后loads取值

Content-Type: application/json.....

    request.body

    request.POST

为了这种情况下每次都要decode，loads，显得麻烦，所以才有的解析器。弥补了django的缺点

 客户端：

             Content-Type: application/json

             '{"name":"alex","age":123}'

         服务端接收：

             读取客户端发送的Content-Type的值 application/json

             parser_classes = [JSONParser,FormParser]  #表示服务器可以解析的数据格式的种类

             media_type_list = ['application/json','application/x-www-form-urlencoded']

             如果客户端的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',

                         'rest_framework.parsers.FormParser',

                     ]

                 }

                 class UserView(APIView):

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

                         return Response('ok')

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

                         print(request.data)  #以后取值就在这里面去取值

                         return Response('...')

具体讲解

传上传文件

 from django.conf.urls import url, include

 from web.views import TestView

 urlpatterns = [

     url(r'test/(?P<filename>[^/]+)', TestView.as_view(), name='test'),

 ]

urls.py

 #!/usr/bin/env python

 # -*- coding:utf-8 -*-

 from rest_framework.views import APIView

 from rest_framework.response import Response

 from rest_framework.request import Request

 from rest_framework.parsers import FileUploadParser

 class TestView(APIView):

     parser_classes = [FileUploadParser, ]

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

         print(filename)

         print(request.content_type)

         # 获取请求的值，并使用对应的JSONParser进行处理

         print(request.data)

         # application/x-www-form-urlencoded 或 multipart/form-data时，request.POST中才有值

         print(request.POST)

         print(request.FILES)

         return Response('POST请求，响应内容')

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

         return Response('PUT请求，响应内容')

views.py

 <!DOCTYPE html>

 <html lang="en">

 <head>

     <meta charset="UTF-8">

     <title>Title</title>

 </head>

 <body>

 <form action="http://127.0.0.1:8000/test/f1.numbers" method="post" enctype="multipart/form-data">

     <input type="text" name="user" />

     <input type="file" name="img">

     <input type="submit" value="提交">

 </form>

 </body>

 </html>

upload.html

全局使用

 REST_FRAMEWORK = {

     'DEFAULT_PARSER_CLASSES':[

         'rest_framework.parsers.JSONParser'

         'rest_framework.parsers.FormParser'

         'rest_framework.parsers.MultiPartParser'

     ]

 }

settings.py

三、序列化

回到顶部

序列化用于对用户请求数据进行验证和数据进行序列化（为了解决queryset序列化问题）。

那什么是序列化呢？序列化就是把对象转换成字符串，反序列化就是把字符串转换成对象

models.py

from django.db import models

# Create your models here.

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 Menu(models.Model):

    name = models.CharField(max_length=21)

class Role(models.Model):

    name = models.CharField(max_length=32)

1、基本操作

 from django.shortcuts import render,HttpResponse

 from rest_framework.views import APIView

 from rest_framework.response import Response

 from rest_framework.versioning import BaseVersioning

 from rest_framework.versioning import QueryParameterVersioning  #获取version的值

 from rest_framework.versioning import URLPathVersioning #支持版本

 from rest_framework.versioning import HostNameVersioning

 from rest_framework.parsers import JSONParser  #解析器

 from rest_framework import serializers

 from app03 import models

 class UsersSerializer(serializers.Serializer):

     name = serializers.CharField()  #字段名字

     pwd = serializers.CharField()

 class UserView(APIView):

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

         # 方式一实现

         # user_list = models.UserInfo.objects.values('name','pwd','group__mu','group__title')

         # print(type(user_list))

         # return Response(user_list)

         # 方式二之多对象

         # user_list = models.UserInfo.objects.all()  #直接这样查会报错，借助他提供的系列化

         # ser = UsersSerializer(instance=user_list,many=True) #可允许多个

         # # print(type(ser))  #<class 'rest_framework.serializers.ListSerializer'>

         # print(ser.data)  #返回的是一个有序字典

         #方式三之单对象

         user = models.UserInfo.objects.all().first()

         ser = UsersSerializer(instance=user,many=False)

         return Response(ser.data)

views.py

2、跨表

 x1 = serializers.CharField(source='group.mu.name')

如果你想跨表拿你任何需要的数据，都可以用上面的这种操作，内部做判断，如果可用内部就加括号调用了

 from rest_framework.views import APIView

 from rest_framework.response import Response

 from rest_framework import serializers

 from app03 import models

 class UsersSerializer(serializers.Serializer):

     name = serializers.CharField()  #字段名字

     pwd = serializers.CharField()

     # group = serializers.CharField()  #会显示对象

     # group_id = serializers.CharField()  #会显示id

     x1 = serializers.CharField(source='group.mu.name')

     roles = serializers.CharField(source='roles.all') #多对多关系的这样查出的是queryset对象

 class UserView2(APIView):

     '''跨表操作'''

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

         user = models.UserInfo.objects.all()

         ser = UsersSerializer(instance=user,many=True)

         return Response(ser.data)

Views.py

3、复杂序列化

解决方案一：

 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") #  多对多关系的这样查出的是queryset对象

     x2 = MyCharField(source="roles.all") # obj.mu.name

Views.py

解决方案二：

 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

Views.py

解决方案三（推荐使用）

 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):  #get_字段名

         print(obj)   ##UserInfo object

         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

Views.py

4、基于Model

 class UsersSerializer(serializers.ModelSerializer):

 x1 = serializers.CharField(source='name')

 group = serializers.HyperlinkedIdentityField(view_name='detail')

 class Meta:

     model = models.UserInfo

     # fields = "__all__"

     fields = ['name','pwd','group','x1']  #自定义字段的时候注意要指定source,scource里面的数据必须是数据库有的数据

     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)

Views.py

5、生成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)

views.py

from django.conf.urls import url,include

from django.contrib import admin

from app03 import views

urlpatterns = [

    url(r'^users4/', views.UserView4.as_view(), name='xxx'), #吧users4的group的值反向生成users5的url

    url(r'^users5/(?P<pk>.*)', views.UserView5.as_view(), name='detail'),  #必须叫pk

    # url(r'^users4/(?P<pk>.*)', views.UserView4.as_view(), name='detail'),

]

6、全局生成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)

views.py

四、请求数据验证：

回到顶部

a、自己手写

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

views.py

b、基于model

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

         }

views.py

使用

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

viewS.py

钩子函数

def validate_字段(self,validated_value):

       raise ValidationError(detail='xxxxxx')

       return validated_value

码农公寓

Restful Framework （三）

目录

一、版本

1、基于url的方式

2、基于子域名传参

二、解析器：reqest.data取值的时候才执行

三、序列化

1、基本操作

2、跨表

3、复杂序列化

4、基于Model

5、生成URL

6、全局生成URL

四、请求数据验证：

码农公寓

目录

一、版本

1、基于url的方式

2、基于子域名传参

二、解析器：reqest.data取值的时候才执行

三、序列化

1、基本操作

2、跨表

3、复杂序列化

4、基于Model

5、生成URL

6、全局生成URL

四、请求数据验证：

相关文章