restframework
一 认证
核心代码
class OrderView(APIView): authentication_classes = [Authentication,] def get(self,request,*args,**kwargs): pass
class Authentication(object): def authenticate(self,request): token = request._request.GET.get('token') token_obj = models.UserToken.objects.filter(token=token).first() if not token_obj: raise exceptions.AuthenticationFailed('用户认证失败！') return (token_obj.user,token_obj) def authenticate_header(self,request): pass
源码流程：
1 dispatch
2 封装request
3 initial方法
4 perform_authentication方法
5 6 request.user
7 self._authenticate方法 返回值有三种情况，空，报错，(request.user,request.auth)
8 循环
1. 认证
a. 问题1：有些API需要用户登录成功之后，才能访问；有些无需登录就能访问。
b. 基本使用认证组件
解决：
a. 创建两张表
b. 用户登录（返回token并保存到数据库）
c. 认证流程原理
- 见图示
d. 再看一遍源码
1. 局部视图使用&全局使用
2. 匿名是request.user = None
e. 内置认证类
1. 认证类，必须继承：from rest_framework.authentication import BaseAuthentication
2. 其他认证类：BasicAuthentication
梳理：
1. 使用
- 创建类:继承BaseAuthentication； 实现：authenticate方法
- 返回值：
- None,我不管了，下一认证来执行。
- raise exceptions.AuthenticationFailed('用户认证失败') # from rest_framework import exceptions
- (元素1，元素2) # 元素1赋值给request.user; 元素2赋值给request.auth
- 局部使用
from rest_framework.authentication import BaseAuthentication,BasicAuthentication
class UserInfoView(APIView):
"""
订单相关业务
"""
authentication_classes = [BasicAuthentication,]
def get(self,request,*args,**kwargs):
print(request.user)
return HttpResponse('用户信息')
- 全局使用：
REST_FRAMEWORK = {
# 全局使用的认证类
"DEFAULT_AUTHENTICATION_CLASSES":['api.utils.auth.FirstAuthtication','api.utils.auth.Authtication', ],
# "UNAUTHENTICATED_USER":lambda :"匿名用户"
"UNAUTHENTICATED_USER":None, # 匿名，request.user = None
"UNAUTHENTICATED_TOKEN":None,# 匿名，request.auth = None
}
2. 源码流程
- dispatch
- 封装request
- 获取定义的认证类（全局/局部），通过列表生成时创建对象。
- initial
- perform_authentication
request.user(内部循环....)
二 权限
问题：不用视图不用权限可以访问
基本使用：
class MyPermission(object):
def has_permission(self,request,view):
if request.user.user_type != 3:
return False
return True
class OrderView(APIView):
"""
订单相关业务(只有SVIP用户有权限)
"""
permission_classes = [MyPermission,]
def get(self,request,*args,**kwargs):
# request.user
# request.auth
self.dispatch
ret = {'code':1000,'msg':None,'data':None}
try:
ret['data'] = ORDER_DICT
except Exception as e:
pass
return JsonResponse(ret)
源码流程：
- ...
梳理：
1. 使用
- 类，必须继承：BasePermission，必须实现：has_permission方法
from rest_framework.permissions import BasePermission
class SVIPPermission(BasePermission):
message = "必须是SVIP才能访问"
def has_permission(self,request,view):
if request.user.user_type != 3:
return False
return True
- 返回值：
- True, 有权访问
- False，无权访问
- 局部
class UserInfoView(APIView):
"""
订单相关业务（普通用户、VIP）
"""
permission_classes = [MyPermission1, ]
def get(self,request,*args,**kwargs):
return HttpResponse('用户信息')
- 全局
REST_FRAMEWORK = {
"DEFAULT_PERMISSION_CLASSES":['api.utils.permission.SVIPPermission']
}
2. 源码流程
三 节流
问题：控制访问频率
import time
VISIT_RECORD = {}
class VisitThrottle(object):
"""60s内只能访问3次"""
def __init__(self):
self.history = None
def allow_request(self,request,view):
# 1. 获取用户IP
remote_addr = request.META.get('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 history[-1] < ctime - 60:
history.pop()
if len(history) < 3:
history.insert(0,ctime)
return True
# return True # 表示可以继续访问
# return False # 表示访问频率太高，被限制
def wait(self):
"""
还需要等多少秒才能访问
:return:
"""
ctime = time.time()
return 60 - (ctime - self.history[-1])
class AuthView(APIView):
"""
用于用户登录认证
"""
authentication_classes = []
permission_classes = []
throttle_classes = [VisitThrottle,]
def post(self,request,*args,**kwargs):
ret = {'code':1000,'msg':None}
try:
user = request._request.POST.get('username')
pwd = request._request.POST.get('password')
obj = models.UserInfo.objects.filter(username=user,password=pwd).first()
if not obj:
ret['code'] = 1001
ret['msg'] = "用户名或密码错误"
# 为登录用户创建token
token = md5(user)
# 存在就更新，不存在就创建
models.UserToken.objects.update_or_create(user=obj,defaults={'token':token})
ret['token'] = token
except Exception as e:
ret['code'] = 1002
ret['msg'] = '请求异常'
return JsonResponse(ret)
源码流程：
...
内置控制频率类：
from rest_framework.throttling import BaseThrottle,SimpleRateThrottle
class VisitThrottle(SimpleRateThrottle):
scope = "Luffy"
def get_cache_key(self, request, view):
return self.get_ident(request)
class UserThrottle(SimpleRateThrottle):
scope = "LuffyUser"
def get_cache_key(self, request, view):
return request.user.username
REST_FRAMEWORK = {
# 全局使用的认证类
"DEFAULT_AUTHENTICATION_CLASSES":['api.utils.auth.FirstAuthtication','api.utils.auth.Authtication', ],
# "DEFAULT_AUTHENTICATION_CLASSES":['api.utils.auth.FirstAuthtication', ],
# "UNAUTHENTICATED_USER":lambda :"匿名用户"
"UNAUTHENTICATED_USER":None, # 匿名，request.user = None
"UNAUTHENTICATED_TOKEN":None,# 匿名，request.auth = None
"DEFAULT_PERMISSION_CLASSES":['api.utils.permission.SVIPPermission'],
"DEFAULT_THROTTLE_CLASSES":["api.utils.throttle.UserThrottle"],
"DEFAULT_THROTTLE_RATES":{
"Luffy":'3/m',
"LuffyUser":'10/m',
}
}
四 版本
1 127.0.0.1:8000/api/users/?version=xx 的样式，在url中通过get传参
1）自定义
class MyVersion(object): def determine_version(self,request,*args,**kwargs): return request._request.GET.get('version') class UserView(APIView): versioning_class = MyVersion def get(self,request,*args,**kwargs): print(request.version) return HttpResponse('用户列表')
2）内置类 QueryParameterVersioning
from rest_framework.views import APIView from rest_framework.versioning import QueryParameterVersioning # class MyVersion(object): # def determine_version(self,request,*args,**kwargs): # return request._request.GET.get('version') class UserView(APIView): versioning_class = QueryParameterVersioning def get(self,request,*args,**kwargs): print(request.version) return HttpResponse('用户列表')
全局设置
REST_FRAMEWORK = { "DEFAULT_VERSION":'v1', "ALLOWED_VERSIONS":['v1','v2'], "VERSION_PARAM":'version', }
2 127.0.0.1:8000/api/v1/users/ 在url中传参，推荐
urlpatterns = [ url(r'^(?P<version>[v1|v2]+)/users/$',views.UserView.as_view()), ]
from rest_framework.versioning import URLPathVersioning class UserView(APIView): def get(self,request,*args,**kwargs): print(request.version) return HttpResponse('用户列表')
REST_FRAMEWORK = { "DEFAULT_VERSIONING_CLASS":"rest_framework.versioning.URLPathVersioning", "DEFAULT_VERSION":'v1', "ALLOWED_VERSIONS":['v1','v2'], "VERSION_PARAM":'version', }
总结： 使用： 配置文件： REST_FRAMEWORK = { "DEFAULT_VERSIONING_CLASS":"rest_framework.versioning.URLPathVersioning", "DEFAULT_VERSION":'v1', "ALLOWED_VERSIONS":['v1','v2'], "VERSION_PARAM":'version', } 路由系统： urlpatterns = [ # url(r'^admin/', admin.site.urls), url(r'^api/', include('api.urls')), ] urlpatterns = [ # url(r'^admin/', admin.site.urls), url(r'^(?P<version>[v1|v2]+)/users/$', views.UsersView.as_view(),name='uuu'), ] 视图： class UsersView(APIView): def get(self,request,*args,**kwargs): # 1. 获取版本 print(request.version) # 2. 获取处理版本的对象 print(request.versioning_scheme) # 3. 反向生成URL（rest framework） u1 = request.versioning_scheme.reverse(viewname='uuu',request=request) print(u1) # 4. 反向生成URL u2 = reverse(viewname='uuu',kwargs={'version':2}) print(u2) return HttpResponse('用户列表')
五 解析器 对请求体数据进行解析
铺垫
request.POST中有值的两个条件
1 请求头要求：Content-Type: application/x-www-form-urlencoded
2 数据体要求：name=alex&age=18&gender=男
如
a:form表单提交，默认符合
b：ajax提交
$.ajax({ url:... type:POST, data:{name:alex,age=18} # 内部转化 name=alex&age=18&gender=男 }) 情况一： $.ajax({ url:... type:POST, headers:{'Content-Type':"application/json"} data:{name:alex,age=18} # 内部转化 name=alex&age=18&gender=男 }) # body有值；POST无 情况二： $.ajax({ url:... type:POST, headers:{'Content-Type':"application/json"} data:JSON.stringfy({name:alex,age=18}) # {name:alex,age:18...} }) # body有值；POST无 # json.loads(request.body)
总结： 使用： 配置： REST_FRAMEWORK = { "DEFAULT_VERSIONING_CLASS":"rest_framework.versioning.URLPathVersioning", "DEFAULT_VERSION":'v1', "ALLOWED_VERSIONS":['v1','v2'], "VERSION_PARAM":'version', "DEFAULT_PARSER_CLASSES":['rest_framework.parsers.JSONParser','rest_framework.parsers.FormParser'] } 使用： class ParserView(APIView): # parser_classes = [JSONParser,FormParser,] """ JSONParser:表示只能解析content-type:application/json头 JSONParser:表示只能解析content-type:application/x-www-form-urlencoded头 """ def post(self,request,*args,**kwargs): """ 允许用户发送JSON格式数据 a. content-type: application/json b. {'name':'alex',age:18} :param request: :param args: :param kwargs: :return: """ """ 1. 获取用户请求 2. 获取用户请求体 3. 根据用户请求头 和 parser_classes = [JSONParser,FormParser,] 中支持的请求头进行比较 4. JSONParser对象去请求体 5. request.data """ print(request.data) return HttpResponse('ParserView') 源码流程 & 本质： a. 本质 请求头 :... 状态码: ... 请求方法:... b. 源码流程 - dispatch: request封装 - request.data
六 序列化
序列化的两个作用：
1） 序列化
2 ）请求数据校验
作用 1
from rest_framework import serializers class RoleSerialize(serializers.Serializer): id = serializers.IntegerField() title = serializers.CharField() class RoleView(APIView): # 方式一 比较low的方法 # def get(self,request,*args,**kwargs): # roles = models.Role.objects.all().values('id','title') # roles = list(roles) # return HttpResponse(json.dumps(roles)) # 方式二 def get(self,request,*args,**kwargs): roles = models.Role.objects.all() ser = RoleSerialize(instance=roles,many=True) print(ser.data) return HttpResponse(json.dumps(ser.data))
进阶1 关于choices
Model:
class UserInfo(models.Model): user_type_choices = ( (1,'NORM'), (2,'VIP'), (3,'SVIP'), ) user_type = models.IntegerField(choices=user_type_choices,default=1) username = models.CharField(max_length=32) password = models.CharField(max_length=64) usergroup = models.ForeignKey(to='UserGroup') roles = models.ManyToManyField('Role')
CBV：
class UserinfoSerialize(serializers.Serializer): user_type = serializers.CharField(source='get_user_type_display') # user_type字典 前面加get_,后面加_display username = serializers.CharField() class UserInfoView(APIView): def get(self,request,*args,**kwargs): users = models.UserInfo.objects.all() ser = UserinfoSerialize(instance=users,many=True) return HttpResponse(json.dumps(ser.data))
进阶二，关于外键
model：
class UserInfo(models.Model): user_type_choices = ( (1,'NORM'), (2,'VIP'), (3,'SVIP'), ) user_type = models.IntegerField(choices=user_type_choices,default=1) username = models.CharField(max_length=32) password = models.CharField(max_length=64) usergroup = models.ForeignKey(to='UserGroup') roles = models.ManyToManyField('Role')
class UserGroup(models.Model): title = models.CharField(max_length=32)
视图：
class UserinfoSerialize(serializers.Serializer): user_type = serializers.CharField(source='get_user_type_display') username = serializers.CharField() group = serializers.CharField(source='usergroup.title') #通过.调用 class UserInfoView(APIView): def get(self,request,*args,**kwargs): users = models.UserInfo.objects.all() ser = UserinfoSerialize(instance=users,many=True) return HttpResponse(json.dumps(ser.data))
进阶三 关于多对多
model
class UserInfo(models.Model): user_type_choices = ( (1,'NORM'), (2,'VIP'), (3,'SVIP'), ) user_type = models.IntegerField(choices=user_type_choices,default=1) username = models.CharField(max_length=32) password = models.CharField(max_length=64) usergroup = models.ForeignKey(to='UserGroup') roles = models.ManyToManyField('Role')
class Role(models.Model): title = models.CharField(max_length=32)
视图：
class UserinfoSerialize(serializers.Serializer): user_type = serializers.CharField(source='get_user_type_display') username = serializers.CharField() group = serializers.CharField(source='usergroup.title') roles = serializers.SerializerMethodField() #自定义显示 def get_roles(self,row): #row 代表当前行的对象， roles_list = row.roles.all() ret = [] for item in roles_list: ret.append({'id':item.id,'title':item.title}) return ret #返回啥，页面显示啥 class UserInfoView(APIView): def get(self,request,*args,**kwargs): users = models.UserInfo.objects.all() ser = UserinfoSerialize(instance=users,many=True) return HttpResponse(json.dumps(ser.data))
进阶四。每个字段都写，很难受，简单的做法
class UserinfoSerialize(serializers.ModelSerializer): class Meta: model = models.UserInfo fields = '__all__' class UserInfoView(APIView): def get(self,request,*args,**kwargs): users = models.UserInfo.objects.all() ser = UserinfoSerialize(instance=users,many=True) return HttpResponse(json.dumps(ser.data))
但是，显示也简单了
[{"id": 1, "user_type": 1, "username": "loda", "password": "123", "usergroup": 2, "roles": [1]}, {"id": 2, "user_type": 1, "username": "s4", "password": "123", "usergroup": 2, "roles": [2, 3]}, {"id": 3, "user_type": 1, "username": "bulldog", "password": "123", "usergroup": 2, "roles": [3]}, {"id": 4, "user_type": 2, "username": "miracle", "password": "123", "usergroup": 1, "roles": [1, 2]}, {"id": 5, "user_type": 2, "username": "krokky", "password": "123", "usergroup": 1, "roles": [1, 3]}, {"id": 6, "user_type": 2, "username": "mind_contrlo", "password": "123", "usergroup": 1, "roles": [3]}]
进阶五 最终版本 混合使用
class UserinfoSerialize(serializers.ModelSerializer): roles = serializers.SerializerMethodField() # 自定义显示 def get_roles(self,row): #row 代表当前行的对象， roles_list = row.roles.all() ret = [] for item in roles_list: ret.append({'id':item.id,'title':item.title}) return ret #返回啥，页面显示啥 class Meta: model = models.UserInfo # fields = '__all__' fields = ['username','password','roles'] class UserInfoView(APIView): def get(self,request,*args,**kwargs): users = models.UserInfo.objects.all() ser = UserinfoSerialize(instance=users,many=True) return HttpResponse(json.dumps(ser.data))
显示：
[{"username": "loda", "password": "123", "roles": [{"id": 1, "title": "carry"}]}, {"username": "s4", "password": "123", "roles": [{"id": 2, "title": "mid"}, {"id": 3, "title": "support"}]}, {"username": "bulldog", "password": "123", "roles": [{"id": 3, "title": "support"}]}, {"username": "miracle", "password": "123", "roles": [{"id": 1, "title": "carry"}, {"id": 2, "title": "mid"}]}, {"username": "krokky", "password": "123", "roles": [{"id": 1, "title": "carry"}, {"id": 3, "title": "support"}]}, {"username": "mind_contrlo", "password": "123", "roles": [{"id": 3, "title": "support"}]}]
进阶六： 自动序列化连表 depth
视图：
class UserinfoSerialize(serializers.ModelSerializer): class Meta: model = models.UserInfo fields = '__all__' depth = 1 class UserInfoView(APIView): def get(self,request,*args,**kwargs): users = models.UserInfo.objects.all() ser = UserinfoSerialize(instance=users,many=True) return HttpResponse(json.dumps(ser.data))
输出： 完美！
[{"id": 1, "user_type": 1, "username": "loda", "password": "123", "usergroup": {"id": 2, "title": "allience"}, "roles": [{"id": 1, "title": "carry"}]}, {"id": 2, "user_type": 1, "username": "s4", "password": "123", "usergroup": {"id": 2, "title": "allience"}, "roles": [{"id": 2, "title": "mid"}, {"id": 3, "title": "support"}]}, {"id": 3, "user_type": 1, "username": "bulldog", "password": "123", "usergroup": {"id": 2, "title": "allience"}, "roles": [{"id": 3, "title": "support"}]}, {"id": 4, "user_type": 2, "username": "miracle", "password": "123", "usergroup": {"id": 1, "title": "liquid"}, "roles": [{"id": 1, "title": "carry"}, {"id": 2, "title": "mid"}]}, {"id": 5, "user_type": 2, "username": "krokky", "password": "123", "usergroup": {"id": 1, "title": "liquid"}, "roles": [{"id": 1, "title": "carry"}, {"id": 3, "title": "support"}]}, {"id": 6, "user_type": 2, "username": "mind_contrlo", "password": "123", "usergroup": {"id": 1, "title": "liquid"}, "roles": [{"id": 3, "title": "support"}]}]
总结：
1. 写类 class RolesSerializer(serializers.Serializer): id = serializers.IntegerField() title = serializers.CharField() class UserInfoSerializer(serializers.ModelSerializer): class Meta: model = models.UserInfo # fields = "__all__" fields = ['id','username','password',] 2. 字段 a. title = serializers.CharField(source="xxx.xxx.xx.xx") b. title = serializers.SerializerMethodField() class UserInfoSerializer(serializers.ModelSerializer): rls = serializers.SerializerMethodField() # 自定义显示 class Meta: model = models.UserInfo fields = ['id','username','password','rls',] # 自定义方法 def get_rls(self, row): role_obj_list = row.roles.all() ret = [] for item in role_obj_list: ret.append({'id':item.id,'title':item.title}) return ret c. 自定义类 3. 自动序列化连表 class UserInfoSerializer(serializers.ModelSerializer): class Meta: model = models.UserInfo # fields = "__all__" fields = ['id','username','password','group','roles'] depth = 1 # 0 ~ 10 4. 生成链接 class UserInfoSerializer(serializers.ModelSerializer): group = serializers.HyperlinkedIdentityField(view_name='gp',lookup_field='group_id',lookup_url_kwarg='xxx') class Meta: model = models.UserInfo # fields = "__all__" fields = ['id','username','password','group','roles'] depth = 0 # 0 ~ 10 class UserInfoView(APIView): def get(self,request,*args,**kwargs): users = models.UserInfo.objects.all() ser = UserInfoSerializer(instance=users,many=True,context={'request': request}) ret = json.dumps(ser.data, ensure_ascii=False) return HttpResponse(ret)
作用2 请求数据校验
class UserGroupSerialize(serializers.Serializer): title = serializers.CharField(error_messages={'required':'标题不能为空'}) class UserGroupView(APIView): def post(self,request,*args,**kwargs): ser = UserGroupSerialize(data=request.data) if ser.is_valid(): print(ser.validated_data['title']) else: print(ser.errors) return HttpResponse('xxx')
钩子函数
def validate_字段名(self,value):
if True:
return value
else:
raise ..
class RoleSerialize(serializers.Serializer): title = serializers.CharField(error_messages={'required':'不能为空！'}) def validate_title(self,value): print(value) if 1: raise exceptions.ValidationError('shabi') else: return value class RoleView(APIView): # 方式一 比较low的方法 # def get(self,request,*args,**kwargs): # roles = models.Role.objects.all().values('id','title') # roles = list(roles) # return HttpResponse(json.dumps(roles)) # 方式二 def post(self,request,*args,**kwargs): roles = models.Role.objects.all() # ser = RoleSerialize(instance=roles,many=True) ser = RoleSerialize(data=request.data) if ser.is_valid(): print(ser.validated_data) else: print(ser.errors) print(ser.errors['title']) # print(ser.data) return HttpResponse('xxx')
七 分页
第一种 看第n页，每页显示n条数据。
啥都不干的最开始的代码。
model
class UserInfo(models.Model): user_type_choices = ( (1,'NORM'), (2,'VIP'), (3,'SVIP'), ) user_type = models.IntegerField(choices=user_type_choices,default=1) username = models.CharField(max_length=32) password = models.CharField(max_length=64) usergroup = models.ForeignKey(to='UserGroup') roles = models.ManyToManyField('Role')
视图 ：单纯的将序列化后的数据返回。
from rest_framework import serializers from api import models class UserinfoSerialize(serializers.ModelSerializer): class Meta: model = models.UserInfo fields = '__all__' depth = 1
class UserInfoView(APIView): def get(self,request,*args,**kwargs): users = models.UserInfo.objects.all() ser = UserinfoSerialize(instance=users,many=True) return HttpResponse(json.dumps(ser.data))
路由
url(r'^(?P<version>[v1|v2]+)/users/$',views.UserInfoView.as_view()),
通过postman，显示如下。很难看。
[{"id": 1, "user_type": 1, "username": "loda", "password": "123", "usergroup": {"id": 2, "title": "allience"}, "roles": [{"id": 1, "title": "carry"}]}, {"id": 2, "user_type": 1, "username": "s4", "password": "123", "usergroup": {"id": 2, "title": "allience"}, "roles": [{"id": 2, "title": "mid"}, {"id": 3, "title": "support"}]}, {"id": 3, "user_type": 1, "username": "bulldog", "password": "123", "usergroup": {"id": 2, "title": "allience"}, "roles": [{"id": 3, "title": "support"}]}, {"id": 4, "user_type": 2, "username": "miracle", "password": "123", "usergroup": {"id": 1, "title": "liquid"}, "roles": [{"id": 1, "title": "carry"}, {"id": 2, "title": "mid"}]}, {"id": 5, "user_type": 2, "username": "krokky", "password": "123", "usergroup": {"id": 1, "title": "liquid"}, "roles": [{"id": 1, "title": "carry"}, {"id": 3, "title": "support"}]}, {"id": 6, "user_type": 2, "username": "mind_contrlo", "password": "123", "usergroup": {"id": 1, "title": "liquid"}, "roles": [{"id": 3, "title": "support"}]}, {"id": 7, "user_type": 2, "username": "akke", "password": "123", "usergroup": {"id": 2, "title": "allience"}, "roles": []}, {"id": 8, "user_type": 3, "username": "matubman", "password": "123", "usergroup": {"id": 1, "title": "liquid"}, "roles": []}, {"id": 9, "user_type": 3, "username": "gh", "password": "123", "usergroup": {"id": 1, "title": "liquid"}, "roles": []}, {"id": 10, "user_type": 1, "username": "hao", "password": "123", "usergroup": {"id": 3, "title": "newbee"}, "roles": []}, {"id": 11, "user_type": 2, "username": "mu", "password": "123", "usergroup": {"id": 3, "title": "newbee"}, "roles": []}, {"id": 12, "user_type": 3, "username": "xiao8", "password": "123", "usergroup": {"id": 3, "title": "newbee"}, "roles": []}, {"id": 13, "user_type": 1, "username": "sansheng", "password": "123", "usergroup": {"id": 3, "title": "newbee"}, "roles": []}, {"id": 14, "user_type": 2, "username": "banana", "password": "123", "usergroup": {"id": 3, "title": "newbee"}, "roles": []}]
运用渲染 进阶1 ：
1 在settings.py 的 installed_apps里 注册rest_framework,
INSTALLED_APPS = [ 'django.contrib.admin', 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.messages', 'django.contrib.staticfiles', 'api.apps.ApiConfig', 'rest_framework', ]
2 导入Response，返回时甚至连都不需要json，都帮你做好了。
from rest_framework.response import Response class UserInfoView(APIView): def get(self,request,*args,**kwargs): users = models.UserInfo.objects.all() ser = UserinfoSerialize(instance=users,many=True) # return HttpResponse(json.dumps(ser.data)) return Response(ser.data)
改完后，页面显示如下。
牛不牛逼！
进阶2
使用内置的分页
from api.utils.serializer.userinfo import UserinfoSerialize from rest_framework.response import Response from rest_framework.pagination import PageNumberPagination class UserInfoView(APIView): def get(self,request,*args,**kwargs): users = models.UserInfo.objects.all() page = PageNumberPagination() #实例化 #返回 分页后的对象，即page_users,而不是所有对象，users page_users = page.paginate_queryset(queryset=users,request=request,view=self) #queryset=从数据库拿到的queryset类型数据，view=当前视图的对象 ser = UserinfoSerialize(instance=page_users,many=True) # return HttpResponse(json.dumps(ser.data)) return Response(ser.data)
内置，可以在url加?page=x，调到某一页。
进阶3 基于PageNumberPagination的基础上自定义分页
from rest_framework.pagination import PageNumberPagination class MyPageNumberPagination(PageNumberPagination): page_size = 3 page_query_param = 'page' page_size_query_param = 'size' max_page_size = 10 class UserInfoView(APIView): def get(self,request,*args,**kwargs): users = models.UserInfo.objects.all() page = MyPageNumberPagination() #实例化 #返回 分页后的对象，即page_users,而不是所有对象，users page_users = page.paginate_queryset(queryset=users,request=request,view=self) #queryset=从数据库拿到的queryset类型数据，view=当前视图的对象 ser = UserinfoSerialize(instance=page_users,many=True) # return HttpResponse(json.dumps(ser.data)) return Response(ser.data)
可以实现内置分页类，并不能实现的在url后面加size参数的功能。另外，尽管全局设置为page=3，当前引用的自定义类，page=2，也是以引用的自定义的分页类为准。
进阶四
返回更为详细的数据
视图
class MyPageNumberPagination(PageNumberPagination): page_size = 3 page_query_param = 'page' page_size_query_param = 'size' max_page_size = 10 class UserInfoView(APIView): def get(self,request,*args,**kwargs): users = models.UserInfo.objects.all() page = MyPageNumberPagination() #实例化 #返回 分页后的对象，即page_users,而不是所有对象，users page_users = page.paginate_queryset(queryset=users,request=request,view=self) #queryset=从数据库拿到的queryset类型数据，view=当前视图的对象 ser = UserinfoSerialize(instance=page_users,many=True) # return HttpResponse(json.dumps(ser.data)) # return Response(ser.data) return page.get_paginated_response(data=ser.data) #！！
访问成功后显示：
其中，next，previous，都是超链接。
第二种 在第n位置，向后查看n条数据
LimitOffsetPagination
from rest_framework.pagination import LimitOffsetPagination class MyPageNumberPagination(LimitOffsetPagination): limit_query_param = 'limit' offset_query_param = 'offset' max_limit = 5 class UserInfoView(APIView): def get(self,request,*args,**kwargs): users = models.UserInfo.objects.all() page = MyPageNumberPagination() #实例化 #返回 分页后的对象，即page_users,而不是所有对象，users page_users = page.paginate_queryset(queryset=users,request=request,view=self) #queryset=从数据库拿到的queryset类型数据，view=当前视图的对象 ser = UserinfoSerialize(instance=page_users,many=True) # return HttpResponse(json.dumps(ser.data)) # return Response(ser.data) return page.get_paginated_response(data=ser.data)
样式：
第三种 加密分页 上一页，下一页
class MyPageNumberPagination(CursorPagination): cursor_query_param = 'cursor' page_size = 4 # invalid_cursor_message = _('Invalid cursor') ordering = 'id' page_size_query_param = 'size' max_page_size = 10 class UserInfoView(APIView): def get(self,request,*args,**kwargs): users = models.UserInfo.objects.all() page = MyPageNumberPagination() #实例化 #返回 分页后的对象，即page_users,而不是所有对象，users page_users = page.paginate_queryset(queryset=users,request=request,view=self) #queryset=从数据库拿到的queryset类型数据，view=当前视图的对象 ser = UserinfoSerialize(instance=page_users,many=True) # return HttpResponse(json.dumps(ser.data)) # return Response(ser.data) return page.get_paginated_response(data=ser.data)
页面显示：
注意，这一种分页，必须使用page.get_paginated_response。因为在url中cursor='' 是什么你是不知道的，只能点上一页，下一页。
八 视图
视图的继承关系
GenericViewSet 实现了 as_view({'get':'xx'...})
视图：
from rest_framework.viewsets import ModelViewSet class UserInfoView(ModelViewSet): queryset = models.UserInfo.objects.all() serializer_class = UserinfoSerialize pagination_class = PageNumberPagination
路由：
url(r'^(?P<version>[v1|v2]+)/users/$',views.UserInfoView.as_view({'post':'create','get':'list'})), url(r'^(?P<version>[v1|v2]+)/users/(?P<pk>\d+)/$',views.UserInfoView.as_view({'get':'retrieve','put':'update','patch':'partial_update','delete':'destroy'})),
总结：
a. 增删改查 ModelViewSet
b. 增删 CreateModelMixin,DestroyModelMixin GenericViewSet
c. 复杂逻辑 GenericViewSet 或 APIView
九 路由
a.
url(r'^(?P<version>[v1|v2]+)/parser/$', views.ParserView.as_view()),
b.
url(r'^(?P<version>[v1|v2]+)/v1/$', views.View1View.as_view({'get': 'list','post':'create'})),
c.
# http://127.0.0.1:8000/api/v1/v1/?format=json
url(r'^(?P<version>[v1|v2]+)/v1/$', views.View1View.as_view({'get': 'list','post':'create'})),
# http://127.0.0.1:8000/api/v1/v1.json
url(r'^(?P<version>[v1|v2]+)/v1\.(?P<format>\w+)$', views.View1View.as_view({'get': 'list','post':'create'})),
url(r'^(?P<version>[v1|v2]+)/v1/(?P<pk>\d+)/$', views.View1View.as_view({'get': 'retrieve','delete':'destroy','put':'update','patch':'partial_update'})),
url(r'^(?P<version>[v1|v2]+)/v1/(?P<pk>\d+)\.(?P<format>\w+)$', views.View1View.as_view({'get': 'retrieve','delete':'destroy','put':'update','patch':'partial_update'})),
d.
from api import views
from rest_framework import routers
router = routers.DefaultRouter()
router.register(r'users', views.UserInfoView)
router.register(r'roles', views.RolesView)
urlpatterns = [
url(r'^(?P<version>[v1|v2]+)/', include(router.urls)),
]
十 渲染
局部渲染
class TestView(APIView): # renderer_classes = [JSONRenderer,BrowsableAPIRenderer] def get(self, request, *args, **kwargs): ...
全局渲染
REST_FRAMEWORK = { "DEFAULT_RENDERER_CLASSES":[ 'rest_framework.renderers.JSONRenderer', 'rest_framework.renderers.BrowsableAPIRenderer', ] }
