Django-Rest-Framework
#前后端混合开发(前后端不分离):返回的是html的内容,需要写模板 #前后端分离:只专注于写后端接口,返回json,xml格式数据 # xml格式 <xml> <name>lqz</name> </xml> # json {"name":"lqz"} # java---》jsp https://www.pearvideo.com/category_loading.jsp #php写的 http://www.aa7a.cn/user.php # python写的 http://www.aa7a.cn/user.html #什么是动态页面(查数据库的),什么是静态页面(静止的html) #页面静态化
#通过网络,规定了前后台信息交互规则的url链接,也就是前后台信息交互的媒介 #百度地图的api接口 https://api.map.baidu.com/place/v2/search?ak=6E823f587c95f0148c19993539b99295®ion=%E4%B8%8A%E6%B5%B7&query=%E8%82%AF%E5%BE%B7%E5%9F%BA&output=xml
# postman是目前最好用的,模拟发送http请求的工具 # 双击安装,安装完成自动打开 # 解析json的网站 http://www.json.cn/ #请求头中User-Agent:客户端的类型 # 请求头中加其他参数: # 批量接口导出和测试(实操一下)
REST全称是Representational State Transfer,中文意思是表述(编者注:通常译为表征性状态转移)。 它首次出现在2000年Roy Fielding的博士论文中。 RESTful是一种定义Web API接口的设计风格,尤其适用于前后端分离的应用模式中。 这种风格的理念认为后端开发任务就是提供数据的,对外提供的是数据资源的访问接口,所以在定义接口时,客户端访问的URL路径就表示这种要操作的数据资源。 事实上,我们可以使用任何一个框架都可以实现符合restful规范的API接口。 # 抓包工具:fiddler,charles # 10条规范 1 数据的安全保障:url链接一般都采用https协议进行传输 注:采用https协议,可以提高数据交互过程中的安全性 2 接口特征表现,一看就知道是个api接口 - 用api关键字标识接口url: - [https://api.baidu.com](https://api.baidu.com/) - https://www.baidu.com/api 注:看到api字眼,就代表该请求url链接是完成前后台数据交互的 -路飞的接口:https://api.luffycity.com/api/v1/course/free/ 3 多数据版本共存 - 在url链接中标识数据版本 - https://api.baidu.com/v1 - https://api.baidu.com/v2 注:url链接中的v1、v2就是不同数据版本的体现(只有在一种数据资源有多版本情况下) 4 数据即是资源,均使用名词(可复数) - 接口一般都是完成前后台数据的交互,交互的数据我们称之为资源 - https://api.baidu.com/users - https://api.baidu.com/books - https://api.baidu.com/book 注:一般提倡用资源的复数形式,在url链接中奖励不要出现操作资源的动词,错误示范:https://api.baidu.com/delete-user - 特殊的接口可以出现动词,因为这些接口一般没有一个明确的资源,或是动词就是接口的核心含义 - https://api.baidu.com/place/search - https://api.baidu.com/login 5 资源操作由请求方式决定(method) - 操作资源一般都会涉及到增删改查,我们提供请求方式来标识增删改查动作 - https://api.baidu.com/books - get请求:获取所有书 - https://api.baidu.com/books/1 - get请求:获取主键为1的书 - https://api.baidu.com/books - post请求:新增一本书书 - https://api.baidu.com/books/1 - put请求:整体修改主键为1的书 - https://api.baidu.com/books/1 - patch请求:局部修改主键为1的书 - https://api.baidu.com/books/1 - delete请求:删除主键为1的书 6 过滤,通过在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:指定筛选条件 7 响应状态码 7.1 正常响应 - 响应状态码2xx - 200:常规请求 - 201:创建成功 7.2 重定向响应 - 响应状态码3xx - 301:永久重定向 - 302:暂时重定向 7.3 客户端异常 - 响应状态码4xx - 403:请求无权限 - 404:请求路径不存在 - 405:请求方法不存在 7.4 服务器异常 - 响应状态码5xx - 500:服务器异常 8 错误处理,应返回错误信息,error当做key { error: "无权限操作" } 9 返回结果,针对不同操作,服务器向用户返回的结果应该符合以下规范 GET /collection:返回资源对象的列表(数组) GET /collection/resource:返回单个资源对象 POST /collection:返回新生成的资源对象 PUT /collection/resource:返回完整的资源对象 PATCH /collection/resource:返回完整的资源对象 DELETE /collection/resource:返回一个空文档 10 需要url请求的资源需要访问资源的请求链接 # Hypermedia API,RESTful API最好做到Hypermedia,即返回结果中提供链接,连向其他API方法,使得用户不查文档,也知道下一步应该做什么 { "status": 0, "msg": "ok", "results":[ { "name":"肯德基(罗餐厅)", "img": "https://image.baidu.com/kfc/001.png" } ... ] }
# 安装:pip install djangorestframework==3.10.3 # 使用 1 在setting.py 的app中注册 INSTALLED_APPS = [ 'rest_framework' ] 2 在models.py中写表模型 class Book(models.Model): nid=models.AutoField(primary_key=True) name=models.CharField(max_length=32) price=models.DecimalField(max_digits=5,decimal_places=2) author=models.CharField(max_length=32) 3 新建一个序列化类(听不懂) from rest_framework.serializers import ModelSerializer from app01.models import Book class BookModelSerializer(ModelSerializer): class Meta: model = Book fields = "__all__" 4 在视图中写视图类 from rest_framework.viewsets import ModelViewSet from .models import Book from .ser import BookModelSerializer class BooksViewSet(ModelViewSet): queryset = Book.objects.all() serializer_class = BookModelSerializer 5 写路由关系 from app01 import views from rest_framework.routers import DefaultRouter router = DefaultRouter() # 可以处理视图的路由器 router.register('book', views.BooksViewSet) # 向路由器中注册视图集 # 将路由器中的所有路由信息追到到django的路由列表中 urlpatterns = [ path('admin/', admin.site.urls), ] #这是什么意思?两个列表相加 # router.urls 列表 urlpatterns += router.urls 6 启动,在postman中测试即可
# ModelViewSet继承View(django原生View) # APIView继承了View # 先读View的源码 from django.views import View # urls.py path('books1/', views.Books.as_view()), #在这个地方应该写个函数内存地址,views.Books.as_view()执行完,是个函数内存地址,as_view是一个类方法,类直接来调用,会把类自动传入 放了一个view的内存地址(View--》as_view--》内层函数) # 请求来了,如果路径匹配,会执行, 函数内存地址(request) def view(request, *args, **kwargs): #request是当次请求的request self = cls(**initkwargs) #实例化得到一个对象,Book对象 if hasattr(self, 'get') and not hasattr(self, 'head'): self.head = self.get self.request = request self.args = args self.kwargs = kwargs return self.dispatch(request, *args, **kwargs) def dispatch(self, request, *args, **kwargs): #request是当次请求的request self是book对象 if request.method.lower() in self.http_method_names: #handler现在是: handler=getattr(self,'get'),你写的Book类的get方法的内存地址 handler = getattr(self, request.method.lower(), self.http_method_not_allowed) else: handler = self.http_method_not_allowed return handler(request, *args, **kwargs) #执行get(request)
#from rest_framework.views import APIView # urls.py path('booksapiview/', views.BooksAPIView.as_view()), #在这个地方应该写个函数内存地址 #APIView的as_view方法(类的绑定方法) def as_view(cls, **initkwargs): view = super().as_view(**initkwargs) # 调用父类(View)的as_view(**initkwargs) view.cls = cls view.initkwargs = initkwargs # 以后所有的请求,都没有csrf认证了,只要继承了APIView,就没有csrf的认证 return csrf_exempt(view) #请求来了---》路由匹配上---》view(request)---》调用了self.dispatch(),会执行apiview的dispatch # APIView的dispatch方法 def dispatch(self, request, *args, **kwargs): self.args = args self.kwargs = kwargs # 重新包装成一个request对象,以后再用的request对象,就是新的request对象了 request = self.initialize_request(request, *args, **kwargs) self.request = request self.headers = self.default_response_headers # deprecate? try: # 三大认证模块 self.initial(request, *args, **kwargs) # Get the appropriate handler method if request.method.lower() in self.http_method_names: handler = getattr(self, request.method.lower(), self.http_method_not_allowed) else: handler = self.http_method_not_allowed # 响应模块 response = handler(request, *args, **kwargs) except Exception as exc: # 异常模块 response = self.handle_exception(exc) # 渲染模块 self.response = self.finalize_response(request, response, *args, **kwargs) return self.response # APIView的initial方法 def initial(self, request, *args, **kwargs): # 认证组件:校验用户 - 游客、合法用户、非法用户 # 游客:代表校验通过,直接进入下一步校验(权限校验) # 合法用户:代表校验通过,将用户存储在request.user中,再进入下一步校验(权限校验) # 非法用户:代表校验失败,抛出异常,返回403权限异常结果 self.perform_authentication(request) # 权限组件:校验用户权限 - 必须登录、所有用户、登录读写游客只读、自定义用户角色 # 认证通过:可以进入下一步校验(频率认证) # 认证失败:抛出异常,返回403权限异常结果 self.check_permissions(request) # 频率组件:限制视图接口被访问的频率次数 - 限制的条件(IP、id、唯一键)、频率周期时间(s、m、h)、频率的次数(3/s) # 没有达到限次:正常访问接口 # 达到限次:限制时间内不能访问,限制时间达到后,可以重新访问 self.check_throttles(request)
from rest_framework.request import Request # 只要继承了APIView,视图类中的request对象,都是新的,也就是上面那个request的对象了 # 老的request在新的request._request # 以后使用reqeust对象,就像使用之前的request是一模一样(因为重写了__getattr__方法) def __getattr__(self, attr): try: return getattr(self._request, attr) #通过反射,取原生的request对象,取出属性或方法 except AttributeError: return self.__getattribute__(attr) # request.data 感觉是个数据属性,其实是个方法,@property,修饰了 它是一个字典,post请求不管使用什么编码,传过来的数据,都在request.data #get请求传过来数据,从哪取? request.GET @property def query_params(self): """ More semantically correct name for request.GET. """ return self._request.GET #视图类中 print(request.query_params) #get请求,地址中的参数 # 原来在 print(request.GET)
# 在视图函数上加装饰器@csrf_exempt # csrf_exempt(view)这么写和在视图函数上加装饰器是一毛一样的 #urls.py中看到这种写法 path('tset/', csrf_exempt(views.test)),
总结1
1 web的两种开发模式 2 web api 3 posman的使用(路径必须完全正确) 4 restful规范 10条 5 drf的安装和使用 6 cbv源码分析 -视图类,必须继承View(读View的源码) -在类里写get,post方法就可以了,只要get请求来,就会走get方法(方法跟之前的fbv写法完全一样) -路由:views.Books.as_view()---这个函数执行完一定是一个内存地址---》view(闭包函数)内存函数的地址 -请求来了,路由匹配上--->view(request)--->self.dispatch(request, *args, **kwargs) -dispatch-->把请求方法转成小写---》通过反射,去对象中找,有没有get方法,有就加括号执行,并且把request传进去了 7 APIView源码分析(drf提供的,扩展了View的功能) -视图类,继承APIView(读APIView的源码) -在类里写get,post方法就可以了,只要get请求来,就会走get方法(方法跟之前的fbv写法完全一样) -路由:views.Books.as_view()---这个函数执行完一定是一个内存地址---》view(闭包函数)内存函数的地址,处理了csrf,所有请求,都没有csrf校验了 -请求来了,路由匹配上--->view(request)--->self.dispatch(request, *args, **kwargs),现在这个dispatch不是View中的dispatch,而是APIView中的dispatch -def dispatch(self, request, *args, **kwargs): self.args = args self.kwargs = kwargs # self.initialize_request(request, *args, **kwargs) request是当次请求的request # request = self.initialize_request request是一个新的Request对象 request = self.initialize_request(request, *args, **kwargs) self.request = request self.headers = self.default_response_headers # deprecate? try: # 三大认证模块(request是新的request) self.initial(request, *args, **kwargs) # Get the appropriate handler method if request.method.lower() in self.http_method_names: handler = getattr(self, request.method.lower(), self.http_method_not_allowed) else: handler = self.http_method_not_allowed # 响应模块 response = handler(request, *args, **kwargs) except Exception as exc: # 异常模块 response = self.handle_exception(exc) # 渲染模块 self.response = self.finalize_response(request, response, *args, **kwargs) return self.response
# 分为两大类: 1. serializers.Serializer # 需要自己重写 create和 update方法 2. serializers.ModelSerializer # 推荐使用 简单方便 # ModelSerializer一般不需要自己写create和update方法 除非特殊需求
1. 序列化,序列化器会把模型对象转换成字典,经过response以后变成json字符串 2. 反序列化,把客户端发送过来的数据,经过request以后变成字典,序列化器可以把字典转成模型 3. 反序列化,完成数据校验功能
1 写一个序列化的类,继承Serializer 2 在类中写要序列化的字段,想序列化哪个字段,就在类中写哪个字段 3 在视图类中使用,导入--》实例化得到序列化类的对象,把要序列化的对象传入 4 序列化类的对象.data 是一个字典 5 把字典返回,如果不使用rest_framework提供的Response,就得使用JsonResponse
from rest_framework import serializers # ser.py class BookSerializer(serializers.Serializer): # id=serializers.CharField() name=serializers.CharField() # price=serializers.DecimalField() price=serializers.CharField() author=serializers.CharField() publish=serializers.CharField() # views.py class BookView(APIView): def get(self,request,pk): book=Book.objects.filter(id=pk).first() #用一个类,毫无疑问,一定要实例化 #要序列化谁,就把谁传过来 book_ser=BookSerializer(book) # 调用类的__init__ # book_ser.data 序列化对象.data就是序列化后的字典 return Response(book_ser.data) # urls.py re_path('books/(?P<pk>\d+)', views.BookView.as_view()),
IntegerField 整型
CharField 字符型
FloatField 浮点型
BooleanField 布尔型
EmailField 邮箱类型
DecimalField 保留小数点型
ImageField 图片型
FileField 文件型
ChoiceField 多重选择型
DateField 日期型
TimeField 时间型
DateTimeField 日期时间型
PrimaryKeyRelatedField 外键关联型
max_length 字符串最大长度
min_length 字符串最小长度
max_value 数字最大值
min_value 数字最小值
read_only 默认False,若设置为True,表明对应字段只在序列化操作中起作用
write_only 默认作用False,若设置为True,表明对应字段只在反序列化操作中起作用
required 默认True,表明对应字段在反序列化操作进行数据校验时必须传入
defalut 字段设置的默认值,设置的同时,required值自动变为False
label 字段的描述
error_messages 字典类型,自定义错误描述,可针对长度、大小、是否必填来设置,如{“required”:“XXX字段不能为空”}
1 写一个序列化的类,继承Serializer 2 在类中写要反序列化的字段,想反序列化哪个字段,就在类中写哪个字段,字段的属性(max_lenth......) max_length 最大长度 min_lenght 最小长度 allow_blank 是否允许为空 trim_whitespace 是否截断空白字符 max_value 最小值 min_value 最大值 3 在视图类中使用,导入--》实例化得到序列化类的对象,把要要修改的对象传入,修改的数据传入 boo_ser=BookSerializer(book,request.data) # 方式一 boo_ser=BookSerializer(instance=book,data=request.data) # 方式二,推荐
# 推荐用方式二:关键字传参的方式 4 数据校验 if boo_ser.is_valid() 5 如果校验通过,就保存 boo_ser.save() # 注意不是book.save() 6 如果不通过,逻辑自己写 7 如果字段的校验规则不够,可以写钩子函数(局部和全局) # 局部钩子 def validate_price(self, data): # validate_字段名 接收前端传过来的该字段参数 #如果价格小于10,就校验不通过 # print(type(data)) # print(data) if float(data)>10: return data else: #校验失败,抛异常 raise ValidationError('价格太低') # 全局钩子 def validate(self, validate_data): # 全局钩子 print(validate_data) author=validate_data.get('author') publish=validate_data.get('publish') if author == publish: raise ValidationError('作者名字跟出版社一样') else: return validate_data 8 可以使用字段的author=serializers.CharField(validators=[check_author]) ,来校验 -写一个函数 def check_author(data): if data.startswith('sb'): raise ValidationError('作者名字不能以sb开头') else: return data -配置:validators=[check_author]
# models.py class Book(models.Model): id=models.AutoField(primary_key=True) name=models.CharField(max_length=32) price=models.DecimalField(max_digits=5,decimal_places=2) author=models.CharField(max_length=32) publish=models.CharField(max_length=32) # ser.py # from rest_framework.serializers import Serializer # 就是一个类 from rest_framework import serializers from rest_framework.exceptions import ValidationError # 需要继承 Serializer def check_author(data): if data.startswith('sb'): raise ValidationError('作者名字不能以sb开头') else: return data class BookSerializer(serializers.Serializer): # id=serializers.CharField() name=serializers.CharField(max_length=16,min_length=4) # price=serializers.DecimalField() price=serializers.CharField() author=serializers.CharField(validators=[check_author]) # validators=[] 列表中写函数内存地址 publish=serializers.CharField() def validate_price(self, data): # validate_字段名 接收前端传过来的该字段参数 #如果价格小于10,就校验不通过 # print(type(data)) # print(data) if float(data)>10: return data else: #校验失败,抛异常 raise ValidationError('价格太低') def validate(self, validate_data): # 全局钩子 print(validate_data) author=validate_data.get('author') publish=validate_data.get('publish') if author == publish: raise ValidationError('作者名字跟出版社一样') else: return validate_data def update(self, instance, validated_data): #instance是book这个对象 #validated_data是校验后的数据 instance.name=validated_data.get('name') instance.price=validated_data.get('price') instance.author=validated_data.get('author') instance.publish=validated_data.get('publish') instance.save() #book.save() django 的orm提供的 return instance #views.py class BookView(APIView): def get(self,request,pk): book=Book.objects.filter(id=pk).first() #用一个类,毫无疑问,一定要实例化 #要序列化谁,就把谁传过来 book_ser=BookSerializer(book) # 调用类的__init__ # book_ser.data 序列化对象.data就是序列化后的字典 return Response(book_ser.data) # return JsonResponse(book_ser.data) def put(self,request,pk): response_msg={'status':100,'msg':'成功'} # 找到这个对象 book = Book.objects.filter(id=pk).first() # 得到一个序列化类的对象,这里跟forms组件类似,
# forms组件校验数据:form_obj=MyForm(request.POST) # boo_ser=BookSerializer(book,request.data) boo_ser=BookSerializer(instance=book,data=request.data) # 要数据验证(回想form表单的验证) if boo_ser.is_valid(): # 返回True表示验证通过 boo_ser.save() # 直接保存会报错,需要在序列化组件的ser.py文件中重写update方法 response_msg['data']=boo_ser.data else: response_msg['status']=101 response_msg['msg']='数据校验失败' response_msg['data']=boo_ser.errors return Response(response_msg) # urls.py re_path('books/(?P<pk>\d+)', views.BookView.as_view()),
read_only 表明该字段仅用于序列化输出,默认False,如果设置成True,postman中可以看到该字段,修改时,不需要传该字段 write_only 表明该字段仅用于反序列化输入,默认False,如果设置成True,postman中看不到该字段,修改时,该字段需要传 # 以下的了解 required 表明该字段在反序列化时必须输入,默认True default 反序列化时使用的默认值 allow_null 表明该字段是否允许传入None,默认False validators 该字段使用的验证器 error_messages 包含错误编号与错误信息的字典
# views.py class BooksView(APIView): def get(self,request): response_msg = {'status': 100, 'msg': '成功'} books=Book.objects.all() book_ser=BookSerializer(books,many=True) #序列化多条,如果序列化一条,不需要写 response_msg['data']=book_ser.data return Response(response_msg) #urls.py path('books/', views.BooksView.as_view()),
# views.py class BooksView(APIView): # 新增 def post(self,request): response_msg = {'status': 100, 'msg': '成功'} #修改才有instance,新增没有instance,只有data book_ser = BookSerializer(data=request.data) # book_ser = BookSerializer(request.data) # 这个按位置传request.data会给instance,就报错了 # 校验字段 if book_ser.is_valid(): book_ser.save() response_msg['data']=book_ser.data else: response_msg['status']=102 response_msg['msg']='数据校验失败' response_msg['data']=book_ser.errors return Response(response_msg) #ser.py 序列化类重写create方法 def create(self, validated_data): instance=Book.objects.create(**validated_data) return instance # urls.py path('books/', views.BooksView.as_view()),
# views.py class BookView(APIView): def delete(self,request,pk): ret=Book.objects.filter(pk=pk).delete() return Response({'status':100,'msg':'删除成功'}) # urls.py re_path('books/(?P<pk>\d+)', views.BookView.as_view()),
class BookModelSerializer(serializers.ModelSerializer): class Meta: model=Book # 对应上models.py中的模型 fields='__all__' # fields=('name','price','id','author') # 只序列化指定的字段 # exclude=('name',) #跟fields不能都写,写谁,就表示排除谁 # read_only_fields=('price',) # write_only_fields=('id',) #弃用了,使用extra_kwargs extra_kwargs = { # 类似于这种形式name=serializers.CharField(max_length=16,min_length=4) 'price': {'write_only': True}, } # 其他使用一模一样 #不需要重写create和updata方法了
# 序列化多条,需要传many=True # book_ser=BookModelSerializer(books,many=True) book_one_ser=BookModelSerializer(book) print(type(book_ser)) #<class 'rest_framework.serializers.ListSerializer'> print(type(book_one_ser)) #<class 'app01.ser.BookModelSerializer'> # 对象的生成--》先调用类的__new__方法,生成空对象 # 对象=类名(name=lqz),触发类的__init__() # 类的__new__方法控制对象的生成 def __new__(cls, *args, **kwargs): if kwargs.pop('many', False): return cls.many_init(*args, **kwargs) # 没有传many=True,走下面,正常的对象实例化 return super().__new__(cls, *args, **kwargs)
# source的使用 1 可以改字段名字 xxx=serializers.CharField(source='title') # 隐藏了一个模型表类book,相当于book.xxx 2 可以.跨表publish=serializers.CharField(source='publish.email') # 相当于book.publish变为book.publish.email 3 可以执行方法pub_date=serializers.CharField(source='test') test是Book表模型中的方法
# 第3详情见下面的示例2
这里需要注意:
要是字段中用了source参数,就在后面的update/局部钩子/全局钩子中,如果使用到该字段校验,
必须使用source指定的参数作为值,否则会出错
# SerializerMethodField()的使用(详情见下面的示例1) 1 它需要有个配套方法,方法名叫get_字段名,返回值就是要显示的东西 authors=serializers.SerializerMethodField() #它需要有个配套方法,方法名叫get_字段名,返回值就是要显示的东西 def get_authors(self,instance): # 这里的instance就是book对象 authors=instance.authors.all() # 取出所有作者 ll=[] for author in authors: ll.append({'name':author.name,'age':author.age}) return ll
1 可以改字段名字 xxx=serializers.CharField(source='title') 2 可以.跨表publish=serializers.CharField(source='publish.email') 3 可以执行方法pub_date=serializers.CharField(source='test') test是Book表模型中的方法 # 上面的序列化类中其实隐藏了一个模型类 publish=serializers.CharField(source='publish.email') # 相当于book.publish=serializers.CharField(source='book.publish.email')
SerializerMethodField
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
# models.py from django.db import models class BaseModel(models.Model): create_time = models.DateTimeField(auto_now_add=True) is_delete = models.BooleanField(default=False) last_update_time = models.DateTimeField(auto_now=True) class Meta: # abstract=True说明是一个抽象类,不会生成表 abstract = True class Book(BaseModel): name = models.CharField(max_length=32) price = models.DecimalField(max_digits=5,decimal_places=2) # db_constraint表示实质上没有外键联系,只是逻辑上的关联,增删不会有影响,同时不影响我们orm查询 publish = models.ForeignKey(to='Publish',db_constraint=False,on_delete=models.DO_NOTHING) # 自动:中间表只有两个表的关联字段,用自动创第三张表的方式 # 手动:中间表有扩展字段,需要用手动的方式,through,through_fields, authors = models.ManyToManyField(to='Author') class Meta: verbose_name_plural = '图书表' def __str__(self): return '%s'% self.name class Publish(BaseModel): name = models.CharField(max_length=32) addr = models.CharField(max_length=255) class Meta: verbose_name_plural = '出版社表' def __str__(self): return '%s'% self.name class Author(BaseModel): name = models.CharField(max_length=32) gender = models.IntegerField(choices=((1,'男'), (2,'女')), ) # OneToOneField本质就是ForeignKey+unique,自己手动写也可以 author_detail = models.OneToOneField(to='AuthorDetail',db_constraint=False,on_delete=models.CASCADE) class Meta: verbose_name_plural = '作者表' def __str__(self): return '%s'% self.name class AuthorDetail(BaseModel): phone = models.CharField(max_length=32) class Meta: verbose_name_plural = '作者详情表' # common_seriralizer.py 序列化器 from rest_framework import serializers from api import models class BookModelSerializer(serializers.ModelSerializer): # SerializerMethodField需要一个配套方法,方法名:get_字段名 publish = serializers.SerializerMethodField() def get_publish(self, instance): # 这里的instance就是模型类 publish_name = instance.publish.name return publish_name authors = serializers.SerializerMethodField() # SerializerMethodField需要一个配套方法,方法名:get_字段名 def get_authors(self, instance): authors = instance.authors.all() # 这里的instance就是模型类中的book对象 l = [] for author in authors: l.append({'name':author.name,'gender':author.get_gender_display()}) return l class Meta: model = models.Book fields = ('name','price','publish','authors',) # depth = 1 # 可以设置深度,查询联表下一级的数据 # views.py 视图函数 from rest_framework.generics import GenericAPIView from rest_framework.response import Response from api import models from api.common_serializers import BookModelSerializer class BookGenericAPIView(GenericAPIView): queryset = models.Book.objects.all().filter(is_delete=False) serializer_class = BookModelSerializer def get(self,request,*args,**kwargs): books = self.get_queryset() book_ser = self.get_serializer(instance=books,many=True) return Response(book_ser.data)
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
from django.db import models # Create your models here. class BaseModel(models.Model): create_time = models.DateTimeField(auto_now_add=True) is_delete = models.BooleanField(default=False) last_update_time = models.DateTimeField(auto_now=True) class Meta: # abstract=True说明是一个抽象类,不会生成表 abstract = True class Book(BaseModel): name = models.CharField(max_length=32) price = models.DecimalField(max_digits=5,decimal_places=2) # db_constraint表示实质上没有外键联系,只是逻辑上的关联,增删不会有影响,同时不影响我们orm查询 publish = models.ForeignKey(to='Publish',db_constraint=False,on_delete=models.DO_NOTHING) # 自动:中间表只有两个表的关联字段,用自动创第三张表的方式 # 手动:中间表有扩展字段,需要用手动的方式,through,through_fields, authors = models.ManyToManyField(to='Author') class Meta: verbose_name_plural = '图书表' @property def publish_name(self): return self.publish.name def author_list(self): author_list = self.authors.all() # 可以用列表生成式代替下面代码块 # l = [] # for author in author_list: #l.append({'name':author.name,'gender':author.get_gender_display()}) # return l return [{'name':author.name,'gender':author.get_gender_display()} for author in author_list] def __str__(self): return '%s'% self.name class Publish(BaseModel): name = models.CharField(max_length=32) addr = models.CharField(max_length=255) class Meta: verbose_name_plural = '出版社表' def __str__(self): return '%s'% self.name class Author(BaseModel): name = models.CharField(max_length=32) gender = models.IntegerField(choices=((1,'男'), (2,'女')), ) # OneToOneField本质就是ForeignKey+unique,自己手动写也可以 author_detail = models.OneToOneField(to='AuthorDetail',db_constraint=False,on_delete=models.CASCADE) class Meta: verbose_name_plural = '作者表' def __str__(self): return '%s'% self.name class AuthorDetail(BaseModel): phone = models.CharField(max_length=32) class Meta: verbose_name_plural = '作者详情表' # common_serializer.py 序列化器 from rest_framework import serializers from api import models class BookModelSerializer(serializers.ModelSerializer): class Meta: model = models.Book # 在模型类中定义一个publish_name方法,推荐 # 但是这种方法会有两个publish,所以要在extra_kwargs中设置只读/只写 fields = ('name','price','publish','publish_name','authors','author_list') # depth = 1 # 可以设置深度,查询联表下一级的数据 extra_kwargs = { 'publish':{"write_only":True}, 'publishj_name':{'read_only':True}, 'authors': {"write_only": True}, 'author_list': {'read_only': True}, } # views.py 视图 from rest_framework.generics import GenericAPIView from rest_framework.response import Response from api import models from api.common_serializers import BookModelSerializer class BookGenericAPIView(GenericAPIView): queryset = models.Book.objects.all().filter(is_delete=False) serializer_class = BookModelSerializer def get(self,request,*args,**kwargs): books = self.get_queryset() book_ser = self.get_serializer(instance=books,many=True) return Response(book_ser.data)
某些需要用到的字段,可以单独写一个序列化器,然后调用该序列化器就可以获取该字段的详细数据
如下面的示例中的teacher字段,我们可以单独写一个teacher的序列化器,
如果要获取teacher相关的字段信息,只需要在CourseModelSerializer中调用该序列化器即可
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
# 路由 router = SimpleRouter() router.register('categories', views.CourseCategoryView, 'categories') router.register('free', views.CouresView, 'free') urlpatterns = [ path('', include(router.urls)), ] # 视图 views.py from .paginations import PageNumberPagination from django_filters.rest_framework import DjangoFilterBackend from rest_framework.filters import OrderingFilter,SearchFilter from .filters import MyFilter class CouresView(GenericViewSet,ListModelMixin,RetrieveModelMixin): queryset = models.Course.objects.filter(is_delete=False,is_show=True).order_by('orders') serializer_class = serializer.CourseModelSerializer pagination_class = PageNumberPagination filter_backends=[DjangoFilterBackend,OrderingFilter] ordering_fields=['id', 'price', 'students'] filter_fields=['course_category','students'] ###serializer from rest_framework import serializers from . import models class CourseCategorySerializer(serializers.ModelSerializer): class Meta: model = models.CourseCategory fields = ['id', 'name'] class TeacherSerializer(serializers.ModelSerializer): class Meta: model = models.Teacher fields = ('name', 'role_name', 'title', 'signature', 'image', 'brief') class CourseModelSerializer(serializers.ModelSerializer): # 子序列化的方式 teacher = TeacherSerializer() class Meta: model = models.Course fields=[ 'id', 'name', 'course_img', 'brief', 'attachment_path', 'pub_sections', 'price', 'students', 'period', 'sections', 'course_type_name', 'level_name', 'status_name', 'teacher', 'section_list', ] # models.py class Course(BaseModel): ... @property def course_type_name(self): return self.get_course_type_display() @property def level_name(self): return self.get_level_display() @property def status_name(self): return self.get_status_display() @property def section_list(self): ll=[] # 根据课程取出所有章节(正向查询,字段名.all()) course_chapter_list=self.coursechapters.all() for course_chapter in course_chapter_list: # 通过章节对象,取到章节下所有的课时(反向查询) # course_chapter.表名小写_set.all() 现在变成了course_chapter.coursesections.all() course_sections_list=course_chapter.coursesections.all() for course_section in course_sections_list: ll.append({ 'name': course_section.name, 'section_link': course_section.section_link, 'duration': course_section.duration, 'free_trail': course_section.free_trail, }) if len(ll)>=4: return ll return ll class Teacher(BaseModel): ... def role_name(self): # 返回角色的中文 return self.get_role_display()
class MyResponse(): def __init__(self): self.status=100 self.msg='成功' @property def get_dict(self): return self.__dict__ if __name__ == '__main__': res=MyResponse() res.status=101 res.msg='查询失败' # res.data={'name':'lqz'} print(res.get_dict)
write_only_fields 不能使用,被弃用了,使用extra_kwargs解决了 extra_kwargs = { 'id': {'write_only': True}, }
总结2
#1 Serializer类,需要序列化什么,必须写一个类继承,想序列化什么字段,就在里面写字段,source的作用(很多字段类) #2 序列化queryset(列表)对象和真正的对象,many=True的作用,instance=要序列化的对象, #3 反序列化 instance=要序列化的对象,data=request.data #4 字段验证,序列化类中,给字段加属性,局部和全局钩子函数,字段属性的validators=[check_author] #5 当在视图中调用 序列化对象.is_valid() boo_ser.is_valid(raise_exception=True) 只要验证不通过,直接抛异常 #6 修改保存---》调用序列化对象.save(),重写Serializer类的update方法 def update(self, instance, validated_data): #instance是book这个对象 #validated_data是校验后的数据 instance.name=validated_data.get('name') instance.price=validated_data.get('price') instance.author=validated_data.get('author') instance.publish=validated_data.get('publish') instance.save() #book.save() django 的orm提供的 return instance #7 序列化得到字典,序列化对象.data #8 自己定义了一个Response对象 class MyResponse(): def __init__(self): self.status=100 self.msg='成功' @property def get_dict(self): return self.__dict__ #9 反序列化的新增 序列化类(data=request.data),如果只传了data,当调用 序列化对象.save(),会触发序列化类的create方法执行,当传了instance和data时,调用 序列化对象.save(),会触发序列化类的update方法执行 #10 重写create方法(可以很复杂) def create(self, validated_data): instance=Book.objects.create(**validated_data) return instance #11 ModelSerializer 跟Model做了一个对应 可以不用重写create/update方法 但是如果他的不符合我们的需求 也可以重写 优先生效自己重写的 class BookModelSerializer(serializers.ModelSerializer): def validate_price(self, data): pass publish=serializers.CharField(source='publish.name') class Meta: model=Book # 对应上models.py中的模型 fields='__all__' # fields=('name','price','id','author','publish') # 只序列化指定的字段 # exclude=('name',) #跟fields不能都写,写谁,就表示排除谁 # read_only_fields=('price',) # write_only_fields=('id',) #弃用了,使用extra_kwargs extra_kwargs = { # 类似于这种形式name=serializers.CharField(max_length=16,min_length=4) 'price': {'write_only': True,'max_length':'16','min_length':'4'}, } ModelSerializer扩展: 1.可以写publish=serializers.CharField(source='publish.name'), 2.可以在extra_kwargs里面扩展,对通过参数进行数据限制 3.可以写局部/全局钩子,跟class Meta同级 #12 如果在ModelSerializer中写一个局部钩子或者全局钩子,如何写? -跟之前一模一样,跟class Meta同级 #13 many=True 能够序列化多条的原因---》__new__是在__init__之前执行的,造出一个空对象 #14 接口:统一子类的行为
请求/响应
drf
# 请求对象 # from rest_framework.request import Request def __init__(self, request, parsers=None, authenticators=None, negotiator=None, parser_context=None): # 二次封装request,将原生request作为drf request对象的 _request 属性 self._request = request def __getattr__(self,item): return getattr(self._request,item) # 请求对象.data:前端以三种编码方式传入的数据,都可以取出来 # 请求对象.query_params 与Django标准的request.GET相同,只是更换了更正确的名称而已。
#from rest_framework.response import Response def __init__(self, data=None, status=None, template_name=None, headers=None, exception=False, content_type=None): #data:你要返回的数据,字典 #status:返回的状态码,默认是200, -from rest_framework import status在这个路径下,它把所有使用到的状态码都定义成了常量 #template_name 渲染的模板名字(自定制模板),不需要了解 #headers:响应头,可以往响应头放东西,就是一个字典 #content_type:响应的编码格式,application/json和text/html; # 浏览器响应成浏览器的格式,postman响应成json格式,通过配置实现的(默认配置) #不管是postman还是浏览器,都返回json格式数据 # drf有默认的配置文件---》先从项目的setting中找,找不到,采用默认的 # drf的配置信息,先从自己类中找--》项目的setting中找---》默认的找 -局部使用:对某个视图类有效 -在视图类中写如下 from rest_framework.renderers import JSONRenderer renderer_classes=[JSONRenderer,] -全局使用:全局的视图类,所有请求,都有效 -在setting.py中加入如下 REST_FRAMEWORK = { 'DEFAULT_RENDERER_CLASSES': ( # 默认响应渲染类 'rest_framework.renderers.JSONRenderer', # json渲染器 'rest_framework.renderers.BrowsableAPIRenderer', # 浏览API渲染器 ) }
# 两个视图基类 APIView GenericAPIView
#### views.py from rest_framework.generics import GenericAPIView from app01.models import Book from app01.ser import BookSerializer # 基于APIView写的 class BookView(APIView): def get(self,request): book_list=Book.objects.all() book_ser=BookSerializer(book_list,many=True) return Response(book_ser.data) def post(self,request): book_ser = BookSerializer(data=request.data) if book_ser.is_valid(): book_ser.save() return Response(book_ser.data) else: return Response({'status':101,'msg':'校验失败'}) class BookDetailView(APIView): def get(self, request,pk): book = Book.objects.all().filter(pk=pk).first() book_ser = BookSerializer(book) return Response(book_ser.data) def put(self, request,pk): book = Book.objects.all().filter(pk=pk).first() book_ser = BookSerializer(instance=book,data=request.data) if book_ser.is_valid(): book_ser.save() return Response(book_ser.data) else: return Response({'status': 101, 'msg': '校验失败'}) def delete(self,request,pk): ret=Book.objects.filter(pk=pk).delete() return Response({'status': 100, 'msg': '删除成功'}) #models.py class Book(models.Model): name=models.CharField(max_length=32) price=models.DecimalField(max_digits=5,decimal_places=2) publish=models.CharField(max_length=32) #ser.py class BookSerializer(serializers.ModelSerializer): class Meta: model=Book fields='__all__' # urls.py path('books/', views.BookView.as_view()), re_path('books/(?P<pk>\d+)', views.BookDetailView.as_view()),
# views.py class Book2View(GenericAPIView): #queryset要传queryset对象,查询了所有的图书 # serializer_class使用哪个序列化类来序列化这堆数据 queryset=Book.objects # queryset=Book.objects.all() serializer_class = BookSerializer def get(self,request): book_list=self.get_queryset() book_ser=self.get_serializer(book_list,many=True) return Response(book_ser.data) def post(self,request): book_ser = self.get_serializer(data=request.data) if book_ser.is_valid(): book_ser.save() return Response(book_ser.data) else: return Response({'status':101,'msg':'校验失败'}) class Book2DetailView(GenericAPIView): queryset = Book.objects serializer_class = BookSerializer def get(self, request,pk): book = self.get_object() book_ser = self.get_serializer(book) return Response(book_ser.data) def put(self, request,pk): book = self.get_object() book_ser = self.get_serializer(instance=book,data=request.data) if book_ser.is_valid(): book_ser.save() return Response(book_ser.data) else: return Response({'status': 101, 'msg': '校验失败'}) def delete(self,request,pk): ret=self.get_object().delete() return Response({'status': 100, 'msg': '删除成功'}) #url.py # 使用GenericAPIView重写的 path('books2/', views.Book2View.as_view()), re_path('books2/(?P<pk>\d+)', views.Book2DetailView.as_view()),
from rest_framework.mixins import ListModelMixin,CreateModelMixin,UpdateModelMixin,DestroyModelMixin,RetrieveModelMixin # views.py class Book3View(GenericAPIView,ListModelMixin,CreateModelMixin): queryset=Book.objects serializer_class = BookSerializer def get(self,request): return self.list(request) def post(self,request): return self.create(request) class Book3DetailView(GenericAPIView,RetrieveModelMixin,DestroyModelMixin,UpdateModelMixin): queryset = Book.objects serializer_class = BookSerializer def get(self, request,pk): return self.retrieve(request,pk) def put(self, request,pk): return self.update(request,pk) def delete(self,request,pk): return self.destroy(request,pk) # urls.py # 使用GenericAPIView+5 个视图扩展类 重写的 path('books3/', views.Book3View.as_view()), re_path('books3/(?P<pk>\d+)', views.Book3DetailView.as_view()),
# views.py from rest_framework.generics import ListAPIView from rest_framework.generics import CreateAPIView from rest_framework.generics import UpdateAPIView from rest_framework.generics import RetrieveAPIView from rest_framework.generics import DestroyAPIView from rest_framework.generics import ListCreateAPIView from rest_framework.generics import RetrieveUpdateAPIView from rest_framework.generics import RetrieveDestroyAPIView from rest_framework.generics import RetrieveUpdateDestroyAPIView # 共9个视图子类 class BookView5(ListAPIView,CreateAPIView): # 查询所有,新增一个 queryset = models.Book.objects serializer_class = BookSerializer # class BookDetailView5(RetrieveAPIView,UpdateAPIView,DestroyAPIView): # 一个个写 class BookDetailView5(RetrieveUpdateDestroyAPIView): # 查1个,删1个,改1个,统一写 queryset = models.Book.objects serializer_class = BookSerializer # urls.py url(r'^books5/',views.BookView5.as_view()), url(r'^book5/(?P<pk>\d+)/',views.BookDetailView5.as_view())
# views.py from rest_framework.viewsets import ModelViewSet class Book5View(ModelViewSet): #5个接口都有,但是路由有点问题 queryset = Book.objects serializer_class = BookSerializer # urls.py # 使用ModelViewSet编写5个接口 path('books5/', views.Book5View.as_view(actions={'get':'list','post':'create'})), #当路径匹配,又是get请求,会执行Book5View的list方法 re_path('books5/(?P<pk>\d+)', views.Book5View.as_view(actions={'get':'retrieve','put':'update','delete':'destroy'})),
# 重写了as_view # 核心代码(所以路由中只要配置了对应关系,比如{'get':'list'}),当get请求来,就会执行list方法 for method, action in actions.items(): #method:get # action:list handler = getattr(self, action) #执行完上一句,handler就变成了list的内存地址 setattr(self, method, handler) #执行完上一句 对象.get=list #for循环执行完毕 对象.get:对着list 对象.post:对着create
继承了ViewSetMixin类后,我们还可以自定义请求方法,
当发起get/post/put/delete/retrieve等这些请求的时候,
可以通过利用actions的反射来执行我们自己写的方法,如下:
# views.py from rest_framework.viewsets import ViewSetMixin class Book6View(ViewSetMixin,APIView): #一定要放在APIVIew前 因为继承类的查找顺序关系 def get_all_book(self,request): print("xxxx") book_list = Book.objects.all() book_ser = BookSerializer(book_list, many=True) return Response(book_ser.data) # urls.py #继承ViewSetMixin的视图类,路由可以改写成这样 path('books6/', views.Book6View.as_view(actions={'get': 'get_all_book'})),
继承ModelViewSet并自定制查询
假如我现在有一个类继承了ModelViewSet类,但是在群查接口中,我只想查出2条或者指定数量的数据,这时我们可以在类内重写list方法,如下
# views.py class BookView2(ModelViewSet): queryset = models.Book.objects serializer_class = BookSerializer # 重写list方法,然后返回的数据截取自己想要的数量即可 def list(self, request, *args, **kwargs): queryset = self.filter_queryset(self.get_queryset()) page = self.paginate_queryset(queryset) if page is not None: serializer = self.get_serializer(page, many=True) return self.get_paginated_response(serializer.data) serializer = self.get_serializer(queryset, many=True) return Response((serializer.data)[:3]) # 只需要在这里截取3条数据 # urls.py path('books2/', views.BookView2.as_view(actions={'get':'list','post':'create'})), re_path('books2/(?P<pk>\d+)', views.BookView2.as_view(actions={'get':'retrieve','put':'update','delete':'destroy'})),
同理,如果我们新增数据的时候不想用框架指定好的方式,我们可以自己在类内重写这个方法。
补充
DRF中通过请求方式不同使用不同的序列化器
在pycharm中查看类的继承关系
总结3
# 1 请求和响应 # 2 请求 Request对象,drf新包装的,Request.data,Request.query_params, 重写了__getattr__, request._request # 3 json模块是否执行反序列化bytes格式 python3.6之后才支持 3.5之前的版本不支持 # 4 考你:视图类的方法中:self.request,就是当次请求的request # 5 Response:类,实例化传一堆参,data=字典,status=状态码(有一堆常量),headers=响应头(字典),content_type=响应的编码方式 # 6 全局和局部配置,响应格式 # 7 drf默认配置文件,查找顺序--》先从类中属性找---》项目的setting找---》drf默认的配置找 # 8 视图家族 -APIView---》继承自View -GenicAPIView---》APIView,做了一些扩展: -queryset = None -serializer_class = None -get_queryset() 经常用 -get_serializer() 经常用 -get_serializer_class() 内部来用,外部会重写 -get_object() 经常用,获取一条数据(pk传过来) -源码解析 queryset = self.filter_queryset(self.get_queryset()) #返回所有数据queryset对象 # lookup_url_kwarg就是pk,路由中有名分组分出来的pk
lookup_url_kwargs=None or pk 得到 ==> lookup_url_kwargs= pk lookup_url_kwarg = self.lookup_url_kwarg or self.lookup_field # {pk:4} 4 浏览器地址中要查询的id号http://127.0.0.1:8000/books6/4/ filter_kwargs = {self.lookup_field: self.kwargs[lookup_url_kwarg]} # 根据pk=4去queryset中get单个对象 obj = get_object_or_404(queryset, **filter_kwargs) self.check_object_permissions(self.request, obj) return obj -5 个视图扩展类(继承了object),每个里面写了一个方法(ListModelMixin:list方法) ListModelMixin, CreateModelMixin, UpdateModelMixin, DestroyModelMixin, RetrieveModelMixin -GenericAPIView的视图子类,9个,继承了GenicAPIView+一个或者两个或者三个视图扩展类 CreateAPIView, ListAPIView, UpdateAPIView, RetrieveAPIView, DestroyAPIView, ListCreateAPIView, RetrieveUpdateDestroyAPIView, RetrieveDestroyAPIView, RetrieveUpdateAPIView -视图集:ModelViewSet,ReadOnlyModelViewSet:继承了上面一堆(5个视图扩展和GenicAPIView)+自己写了一个ViewSetMixin(as_view方法),只要继承它的,路由得写成{‘get’:‘自己定义的方法’} -ViewSet=ViewSetMixin, views.APIView :ViewSetMixin要放在前面 -GenericViewSet=ViewSetMixin+GenicAPIView -ViewSetMixin(as_view方法) -ViewSetMixin+APIView=ViewSet -ViewSetMixin+GenicAPIView=GenericViewSet
# 1 在urls.py中配置 path('books4/', views.Book4View.as_view()), re_path('books4/(?P<pk>\d+)', views.Book4DetailView.as_view()),
# 2 一旦视图类,继承了ViewSetMixin,路由 path('books5/', views.Book5View.as_view(actions={'get':'list','post':'create'})), #当路径匹配,又是get请求,会执行Book5View的list方法 re_path('books5/(?P<pk>\d+)', views.Book5View.as_view(actions={'get':'retrieve','put':'update','delete':'destroy'})), # 3 继承自视图类,ModelViewSet的路由写法(自动生成路由) -urls.py # 第一步:导入routers模块 from rest_framework import routers
# 第二步:有两个类,实例化得到对象 # routers.DefaultRouter 生成的路由更多 # routers.SimpleRouter router=routers.DefaultRouter()
# 第三步:注册 # router.register('前缀','继承自ModelViewSet视图类','别名') router.register('books',views.BookViewSet) # 不要加斜杠了 # 第四步 # router.urls # 自动生成的路由,加入到原路由中 # print(router.urls) # urlpatterns+=router.urls
''' -views.py from rest_framework.viewsets import ModelViewSet from app01.models import Book from app01.ser import BookSerializer class BookViewSet(ModelViewSet): queryset =Book.objects serializer_class = BookSerializer
# action干什么用?为了给继承自ModelViewSet的视图类中定义的函数也添加路由
from rest_framework.decorators import action
# 使用 class BookViewSet(ModelViewSet): queryset =Book.objects.all() serializer_class = BookSerializer # methods第一个参数,传一个列表,列表中放请求方式, # ^books/get_1/$ [name='book-get-1'] 当向这个地址发送get请求,会执行下面的函数 # detail:布尔类型 如果是True,参数中需要带pk,如果detail为False,则不需要带pk #^books/(?P<pk>[^/.]+)/get_1/$ [name='book-get-1'] @action(methods=['GET','POST'],detail=True) # detail为True则需要带pk def get_1(self,request,pk): print(pk) book=self.get_queryset()[:2] # 从0开始截取一条 ser=self.get_serializer(book,many=True) return Response(ser.data) # 装饰器,放在被装饰的函数上方,method:请求方式,detail:是否带pk
# 认证的实现 1 写一个类,继承BaseAuthentication,重写authenticate,认证的逻辑写在里面,
认证通过,返回两个值,一个值最终给了Requet对象的user,一个给Request对象的auth,
认证失败,抛异常:APIException或者AuthenticationFailed
2 全局使用:在settings.py中配置 局部使用:在需要认证的函数上方加上 authentication_classes=[自己写的认证类]
#1 APIVIew----》dispatch方法---》self.initial(request, *args, **kwargs)---->有认证,权限,频率 #2 只读认证源码: self.perform_authentication(request) #3 self.perform_authentication(request)就一句话:request.user,需要去drf的Request对象中找user属性(方法) #4 Request类中的user方法,刚开始来,没有_user,走 self._authenticate() #5 核心,就是Request类的 _authenticate(self): def _authenticate(self): # 遍历拿到一个个认证器,进行认证 # self.authenticators自己在视图函数配置的一堆认证类产生的认证类对象组成的 list #self.authenticators 你在视图类中配置的一个个的认证类:authentication_classes=[认证类1(),认证类2()],对象的列表 for authenticator in self.authenticators: try: # 认证器(对象)调用认证方法authenticate(认证类对象self, request请求对象) # 返回值:登陆的用户与认证的信息组成的 tuple # 该方法被try包裹,代表该方法会抛异常,抛异常就代表认证失败 user_auth_tuple = authenticator.authenticate(self) #注意这self是request对象 except exceptions.APIException: self._not_authenticated() raise # 返回值的处理 if user_auth_tuple is not None: self._authenticator = authenticator # 如何有返回值,就将 登陆用户 与 登陆认证 分别保存到 request.user、request.auth self.user, self.auth = user_auth_tuple return # 如果返回值user_auth_tuple为空,代表认证通过,但是没有 登陆用户 与 登陆认证信息,代表游客 self._not_authenticated()
# 自定义认证类: 1.写一个认证类,继承BaseAuthentication,重写authenticate方法, 2.在该方法中书写认证逻辑,如果认证通过返回两个值,分别给user对象和auth对象 如果认证失败则抛出AuthenticationFailed异常 3.在视图类或者settings中配置即可
# 写一个认证类 app_auth.py from rest_framework.authentication import BaseAuthentication from rest_framework.exceptions import AuthenticationFailed from app01.models import UserToken class MyAuthentication(BaseAuthentication): def authenticate(self, request): # 认证逻辑,如果认证通过,返回两个值 #如果认证失败,抛出AuthenticationFailed异常 token=request.GET.get('token') if token: user_token=UserToken.objects.filter(token=token).first() # 认证通过 if user_token: return user_token.user,token else: raise AuthenticationFailed('认证失败') else: raise AuthenticationFailed('请求地址中需要携带token') # 可以有多个认证,从左到右依次执行 # 全局使用,在setting.py中配置 REST_FRAMEWORK={ "DEFAULT_AUTHENTICATION_CLASSES":["app01.app_auth.MyAuthentication",] } # 局部使用,在视图类上写 authentication_classes=[MyAuthentication] # 局部禁用 authentication_classes=[]
示例
# models.py from django.db import models class Book(models.Model): bid = models.AutoField(primary_key=True) name = models.CharField(max_length=32) price = models.DecimalField(max_digits=5,decimal_places=2) author = models.CharField(max_length=32) class MyUser(models.Model): username = models.CharField(max_length=32) password = models.CharField(max_length=32) user_type = models.IntegerField(choices=((1,'超级用户'),(2,'普通用户'),(3,'沙雕用户'))) class UserToken(models.Model): token = models.CharField(max_length=64) user = models.OneToOneField(to='MyUser') # ser.py 自定义序列化器 from rest_framework.serializers import ModelSerializer from app01 import models class MyBook(ModelSerializer): class Meta: model = models.Book fields = '__all__' #user_auth.py 自定义认证组件 from rest_framework.authentication import BaseAuthentication from rest_framework.exceptions import AuthenticationFailed from app01 import models class MyAuthentication(BaseAuthentication): def authenticate(self, request): ''' 书写认证逻辑 如果认证通过,返回两个值,一个给request的user,一个给request的auth 如果认证失败,抛出AuthenticationFailed异常 ''' # 让用户必须在请求地址中带上token(在哪里带上token由我们决定) token = request.GET.get('token') print(token) if token: user_obj = models.UserToken.objects.filter(token=token).first() # 如果用户存在,说明认证通过 if user_obj: print('111',user_obj.token) return user_obj.user,token else: raise AuthenticationFailed('认证失败') else: raise AuthenticationFailed('你给我在地址中带着token来') # views.py from rest_framework.viewsets import ModelViewSet from app01 import models from app01.ser import MyBook from rest_framework.views import APIView from rest_framework.response import Response import uuid class LoginView(APIView): def post(self,request): username = request.data.get('username') password = request.data.get('password') user_obj = models.MyUser.objects.filter(username=username,password=password).first() if user_obj: token = uuid.uuid4() # 通过uuid生成随机字符串 models.UserToken.objects.update_or_create(defaults={'token':token},user=user_obj) return Response({'status':'100','msg':'登录成功','token':token}) else: return Response({'status':'101','msg':'用户名或密码错误'}) from app01.user_auth import MyAuthentication class BookViewSet(ModelViewSet): authentication_classes = [MyAuthentication,] queryset = models.Book.objects.all() serializer_class = MyBook # urls.py from django.conf.urls import url from django.contrib import admin from app01 import views from rest_framework.routers import DefaultRouter,SimpleRouter router = SimpleRouter() router.register('book',views.BookViewSet,) urlpatterns = [ url(r'^admin/', admin.site.urls), url(r'^login/',views.LoginView.as_view()), url(r'^test/',views.TestApi.as_view()), ] urlpatterns += router.urls
总结
# 1 路由 # 2 3种写法 -django传统的路由(cvb路由)path('test/', views.TestView.as_view()), -只要继承ViewSetMixin:path('books/', views.BookViewSet.as_view({'get':'list','post':'create'})), -自动生成路由 -SimpleRouter -DefaultRouter -使用: # 第一步:导入routers模块 from rest_framework import routers # 第二步:有两个类,实例化得到对象 # routers.DefaultRouter 生成的路由更多 # routers.SimpleRouter router=routers.SimpleRouter() # 第三步:注册 # router.register('前缀','继承自ModelViewSet视图类','别名') router.register('books',views.BookViewSet) # 不要加斜杠了 urlpatterns+=router.urls #3 action的使用:装饰器给继承了ModeViewSet的视图类中自定义的方法,自动生成路由 #4 method=['get','post'],detail=True(带pk的)/False(不带pk) # 5 认证 -使用 -定义一个类,继承BaseAuthentication,重写def authenticate(self, request),校验成功返回两个值,一个是user对象,第二个是token -需要注意,如果配置多个认证类,要把返回两个值的放到最后 -全局使用:setting配置 REST_FRAMEWORK={ "DEFAULT_AUTHENTICATION_CLASSES":["app01.app_auth.MyAuthentication",], } -局部使用: authentication_classes=[MyAuthentication] -局部禁用:authentication_classes = []
# APIView---->dispatch---->initial--->self.check_permissions(request)(APIView的对象方法) def check_permissions(self, request): # 遍历权限对象列表得到一个个权限对象(权限器),进行权限认证 for permission in self.get_permissions(): # 权限类一定有一个has_permission权限方法,用来做权限认证的 # 参数:权限对象self、请求对象request、视图类对象 # 返回值:有权限返回True,无权限返回False if not permission.has_permission(request, self): self.permission_denied( request, message=getattr(permission, 'message', None) )
# 自定义权限 1.写一个类,继承BasePermission,重写has_permission方法, 2.书写逻辑,如果权限通过,返回True,如果不通过,返回False 3.配置在视图类或settings中即可
# 写一个类,继承BasePermission,重写has_permission,如果权限通过,就返回True,不通过就返回False from rest_framework.permissions import BasePermission class UserPermission(BasePermission): def has_permission(self, request, view): # 不是超级用户,不能访问 # 由于认证已经过了,request内就有user对象了,当前登录用户 user=request.user # 当前登录用户 # 如果该字段用了choice,通过get_字段名_display()就能取出choice后面的中文 print(user.get_user_type_display()) if user.user_type==1: return True else: return False # 局部使用 class TestView(APIView): permission_classes = [app_auth.UserPermission] # 全局使用 REST_FRAMEWORK={ "DEFAULT_AUTHENTICATION_CLASSES":["app01.app_auth.MyAuthentication",], 'DEFAULT_PERMISSION_CLASSES': [ 'app01.app_auth.UserPermission', ], } # 局部禁用 class TestView(APIView): permission_classes = []
# 演示一下内置权限的使用:IsAdminUser,控制是否对网站后台有权限的人 # 1 创建超级管理员 # 2 写一个测试视图类 from rest_framework.permissions import IsAdminUser from rest_framework.authentication import SessionAuthentication class TestView3(APIView): authentication_classes=[SessionAuthentication,] permission_classes = [IsAdminUser] def get(self,request,*args,**kwargs): return Response('这是22222222测试数据,超级管理员可以看') # 3 超级用户登录到admin,再访问test3就有权限 # 4 正常的话,普通管理员,没有权限看(判断的是is_staff字段)
# 自定义频率 1.写一个类,继承SimpleRateThrottle,重写get_cache_key方法, 2.该方法返回什么就以什么为key进行限制, scope字段需要和settings中的对应 3.在视图类或者settings中配置即可
# 全局配置 # 自定义频率,必须重写get_cache_key # 继承SimpleRateThrottle # 重写get_cache_key,返回什么就以什么为key进行限制 # scope字段,需要与setting中对应 REST_FRAMEWORK = { 'DEFAULT_THROTTLE_CLASSES': [ 'rest_framework.throttling.AnonRateThrottle', 'rest_framework.throttling.UserRateThrottle', ], 'DEFAULT_THROTTLE_RATES': { 'anon': '2/min', 'user': '10/min' } }
# 全局使用 限制未登录用户1分钟访问5次 REST_FRAMEWORK = { 'DEFAULT_THROTTLE_CLASSES': ( 'rest_framework.throttling.AnonRateThrottle', ), 'DEFAULT_THROTTLE_RATES': { 'anon': '3/m', } } ##############views.py from rest_framework.permissions import IsAdminUser from rest_framework.authentication import SessionAuthentication,BasicAuthentication class TestView4(APIView): authentication_classes=[] permission_classes = [] def get(self,request,*args,**kwargs): return Response('我是未登录用户') # 局部使用 from rest_framework.permissions import IsAdminUser from rest_framework.authentication import SessionAuthentication,BasicAuthentication from rest_framework.throttling import AnonRateThrottle class TestView5(APIView): authentication_classes=[] permission_classes = [] throttle_classes = [AnonRateThrottle] def get(self,request,*args,**kwargs): return Response('我是未登录用户,TestView5')
# 需求:未登录用户1分钟访问5次,登录用户一分钟访问10次 全局:在setting中 'DEFAULT_THROTTLE_CLASSES': ( 'rest_framework.throttling.AnonRateThrottle', 'rest_framework.throttling.UserRateThrottle' ), 'DEFAULT_THROTTLE_RATES': { 'user': '10/m', 'anon': '5/m', } 局部配置:throttle_classes = [UserRateThrottle] class TestView6(APIView): authentication_classes=[] permission_classes = [] # 局部配置限制登录用户访问频次 throttle_classes = [UserRateThrottle] def get(self,request,*args,**kwargs): return Response('我是登录用户,TestView6')
DEFAULT_FILTER_BACKENDS' ,
所以这两个组件要不就一起全局配置,要不就一起局部配置,
如果某个视图类局部配置了过滤,全局的就会过滤、排序都会失效(因为共用配置项),
导致这个视图类的排序功能也失效了,所以一定要注意。
#1 安装:pip3 install django-filter #2 注册,在app中注册:'django_filters' #3 全局配,或者局部配 'DEFAULT_FILTER_BACKENDS': ('django_filters.rest_framework.DjangoFilterBackend',) #4 视图类
from django_filters.rest_framework import DjangoFilterBackend
from rest_framework.filters import OrderingFilter
class BookView(ListAPIView):
queryset = Book.objects.all()
serializer_class = BookSerializer
# 局部使用
filter_backends = [DjangoFilterBackend] filter_fields = ('name','price') #配置可以按照哪个字段来过滤 # urls.py path('books/', views.BookView.as_view()), # 使用: http://127.0.0.1:8000/books/?name=微信 http://127.0.0.1:8000/books/?name=微博 http://127.0.0.1:8000/books/?price=12
所以这两个组件要不就一起全局配置,要不就一起局部配置,
如果某个视图类局部配置了排序,全局的排序、过滤都会失效(因为共用配置项),
所以会导致这个视图类过滤功能也失效了,所以一定要注意
# 局部使用和全局使用
# 注册app:在settings文件中注册'django_filters'
# 全局使用
'DEFAULT_FILTER_BACKENDS': ('django_filters.rest_framework.DjangoFilterBackend',) # 局部使用 from rest_framework.generics import ListAPIView
from django_filters.rest_framework import DjangoFilterBackend from rest_framework.filters import OrderingFilter from app01.models import Book from app01.ser import BookSerializer
class Book2View(ListAPIView): queryset = Book.objects.all() serializer_class = BookSerializer filter_backends = [OrderingFilter] # 局部使用 ordering_fields = ('id', 'price')
# 还可以过滤、排序两个一起使用
# filter_backends = [DjangoFilterBackend, OrderingFilter] # filter_fileds = ('name','price')
# ordering_fields = ('id','price')
# urls.py path('books2/', views.Book2View.as_view()), ] # 使用: http://127.0.0.1:8000/books2/?ordering=-price # 降序 http://127.0.0.1:8000/books2/?ordering=price # 升序 http://127.0.0.1:8000/books2/?ordering=-id
# 自定义过滤类:
1.写一个类,继承BaseFilterBackend,
2.重写filter_queryset方法,方法返回queryset对象,就是过滤后的对象,
(前端传过来的url中的参数,可以重query_params中取,其他的规则自己定)
3.配置在视图类中即可
# 借助django-filter实现区间过滤 # 实现区间过滤 ########## 1 filters.py from django_filters import filters from django_filters import FilterSet class CourseFilterSet(FilterSet): # 课程的价格范围要大于min_price,小于max_price min_price = filters.NumberFilter(field_name='price', lookup_expr='gt') max_price = filters.NumberFilter(field_name='price', lookup_expr='lt') class Meta: model=models.Course fields=['course_category'] ##### 2 视图类中配置 -filter_backends=[DjangoFilterBackend] # 配置类:(自己写的类) -filter_class = CourseFilterSet
''' 内置排序:不需要借助第三方模块,rest_framework自带的排序 from rest_framework.filters import OrderingFilter,SearchFilter 按id正序倒叙排序,按price正序倒叙排列 使用:http://127.0.0.1:8000/course/free/?ordering=-id 配置类: filter_backends=[OrderingFilter] 配置字段: ordering_fields=['id','price'] 内置过滤:rest_framework自带的过滤 不支持外键字段来过滤 只支持自有字段的过滤 from rest_framework.filters import OrderingFilter,SearchFilter 使用:http://127.0.0.1:8000/course/free/?search=39 按照price过滤(表自有的字段直接过滤) 配置类: filter_backends=[SearchFilter] 配置字段: search_fields=['price']
自定义过滤:
继承类BaseFilterBackend,重写filter_queryset方法,该方法返回一个queryset对象,
就是过滤后的对象,配置在视图类中即可(过滤需要的参数可以重前端url传过来的query_params中取)
用第三方模块来过滤: 扩展:django-filter 安装:pip install django-filter
注册:在settings配置中注册应用:'django_filters' 支持自有字段的过滤还支持外键字段的过滤 from django_filters.rest_framework import DjangoFilterBackend
http://127.0.0.1:8000/course/free/?course_category=1 # 过滤分类为1 (python的所有课程) 配置类: filter_backends=[DjangoFilterBackend] 配置字段: filter_fields=['course_category'] '''
#统一接口返回 # 自定义异常方法,在settings中替换原本的异常捕获 # 写一个方法 # 自定义异常处理的方法 from rest_framework.views import exception_handler from rest_framework.response import Response from rest_framework import status def my_exception_handler(exc, context): response=exception_handler(exc, context) # 上面那句话调用原来处理异常的函数,赋值给response # 这时response会有两种情况,一个是None,drf没有处理异常 # 另一个是原来的response对象,django处理了异常,但是处理的不符合咱们的要求 # print(type(exc)) # exc就是异常类型 if not response: # 即如果response为None if isinstance(exc, ZeroDivisionError): #可以分的更细,每种异常状态码不同 return Response(data={'status': 777, 'msg': "除以0的错误" + str(exc)}, status=status.HTTP_400_BAD_REQUEST) return Response(data={'status':999,'msg':str(exc)},status=status.HTTP_400_BAD_REQUEST) else: # return response # 就是原来的response对象,处理了异常,但是格式不符合我们要求 # 所以,在下面,我们自己封装响应的格式 return Response(data={'status':888,'msg':response.data.get('detail')},status=status.HTTP_400_BAD_REQUEST) # 全局配置setting.py 'EXCEPTION_HANDLER': 'app01.app_auth.my_exception_handler', ''' 总结: 1.自定义一个异常捕获方法,在该方法内调用drf的异常捕获方法,赋值给response 2.看源码得知,这个response会有两种情况,一种是处理了异常,另一个就是None(没处理异常) 3.我们通过判断response是否为None,来分情况处理异常 如果为response为None:我们自己通过drf的Response对象封装一个字典返回给前端(包含错误信息) 如果response不为None:drf本身已经处理过异常,只是响应的格式不符合我们的要求, 我们也是自己通过drf的Response对象,把drf处理过的异常信息提取出来, 封装到字典中,然后返回给前端。 甚至:在response不为None时,我们可以分的更细,不同的异常类型可以返回不同的响应状态码,如上面的 if isinstance(exc, ZeroDivisionError): return Response{data:xxx,status:xxx,msg:xxx} '''
# 以后都用自己封装的 from rest_framework.response import Response class APIResponse(Response): # 继承drf的Response def __init__(self,code=100,msg='成功',data=None,status=None,headers=None,**kwargs): dic = {'code': code, 'msg': msg} if data: # 如果有data值,将data也封装到字典中 dic = {'code': code, 'msg': msg,'data':data} dic.update(kwargs) # 没有data值,直接用更新字典的方式,将多传入的参数加到字典中 super().__init__(data=dic, status=status,headers=headers) # 继承需要用的父类字段,不用的可以不加,如果后续需要可以再加 # 使用 return APIResponse(data={"name":'lqz'},token='dsafsdfa',aa='dsafdsafasfdee') return APIResponse(data={"name":'lqz'}) return APIResponse(code='101',msg='错误',data={"name":'lqz'},token='dsafsdfa',aa='dsafdsafasfdee',header={})
a=(3,) a=3, # a是元组 print(type(a))
总结
# 1 web开发模型,混合开发和前后端分离 # 2 web api:接口 # 3 postman的使用 # 4 restful规范:10条 # 5 djangorestframework,django的第三方插件(app) # 6 drf几大组件 请求(APIView源码,Requset对象)和响应(Response,自己封装Response), 序列化, 视图, 路由, 解析器(DEFAULT_PARSER_CLASSES,全局配置,局部配置), 响应器(DEFAULT_RENDERER_CLASSES,全局配,局部配), 认证:校验是否登录(有内置,自定义,全局配置,局部配置) 权限:是否有权限访问某些接口(有内置,自定义,全局配置,局部配置) 频率:限制访问频次(有内置,自定义,全局配置,局部配置),根据用户ip,根据用户id限制 过滤:筛选,查询出符合条件的 排序:结果进行排序 异常:全局异常(自定义,全局配置) 版本控制 分页器 文档生成 jwt认证 Xadmin的使用 路飞项目 git redis 短信 支付宝支付
# models.py from django.db import models from django.contrib.auth.models import AbstractUser class BaseModel(models.Model): is_delete=models.BooleanField(default=False) # auto_now_add=True 只要记录创建,不需要手动插入时间,自动把当前时间插入 create_time=models.DateTimeField(auto_now_add=True) # auto_now=True,只要更新,就会把当前时间插入 last_update_time=models.DateTimeField(auto_now=True) # import datetime # create_time=models.DateTimeField(default=datetime.datetime.now) class Meta: # 单个字段,有索引,有唯一 # 多个字段,有联合索引,联合唯一 abstract=True # 抽象表,不再数据库建立出表 class Book(BaseModel): id=models.AutoField(primary_key=True) # verbose_name admin中显示中文 name=models.CharField(max_length=32,verbose_name='书名',help_text='这里填书名') price=models.DecimalField(max_digits=5,decimal_places=2) # 一对多的关系一旦确立,关联字段写在多的一方 #to_field 默认不写,关联到Publish主键 #db_constraint=False 逻辑上的关联,实质上没有外键练习,增删不会受外键影响,但是orm查询不影响 publish=models.ForeignKey(to='Publish',on_delete=models.DO_NOTHING,db_constraint=False) # 多对多,跟作者,关联字段写在 查询次数多的一方 # 什么时候用自动,什么时候用手动?第三张表只有关联字段,用自动 第三张表有扩展字段,需要手动写 # 不能写on_delete authors=models.ManyToManyField(to='Author',db_constraint=False) class Meta: verbose_name_plural='书表' # admin中表名的显示 def __str__(self): return self.name @property def publish_name(self): return self.publish.name # def author_list(self): def author_list(self): author_list=self.authors.all() # ll=[] # for author in author_list: # ll.append({'name':author.name,'sex':author.get_sex_display()}) # return ll return [ {'name':author.name,'sex':author.get_sex_display()}for author in author_list] class Publish(BaseModel): name = models.CharField(max_length=32) addr=models.CharField(max_length=32) def __str__(self): return self.name class Author(BaseModel): name=models.CharField(max_length=32) sex=models.IntegerField(choices=((1,'男'),(2,'女'))) # 一对一关系,写在查询频率高的一方 #OneToOneField本质就是ForeignKey+unique,自己手写也可以 authordetail=models.OneToOneField(to='AuthorDetail',db_constraint=False,on_delete=models.CASCADE) class AuthorDetail(BaseModel): mobile=models.CharField(max_length=11) # 二、表断关联 # 1、表之间没有外键关联,但是有外键逻辑关联(有充当外键的字段) # 2、断关联后不会影响数据库查询效率,但是会极大提高数据库增删改效率(不影响增删改查操作) # 3、断关联一定要通过逻辑保证表之间数据的安全,不要出现脏数据,代码控制 # 4、断关联 # 5、级联关系 # 作者没了,详情也没:on_delete=models.CASCADE # 出版社没了,书还是那个出版社出版:on_delete=models.DO_NOTHING # 部门没了,员工没有部门(空不能):null=True, on_delete=models.SET_NULL # 部门没了,员工进入默认部门(默认值):default=0, on_delete=models.SET_DEFAULT
ser.py
ser.py from rest_framework import serializers from api import models #写一个类,继ListSerializer,重写update class BookListSerializer(serializers.ListSerializer): # def create(self, validated_data): # print(validated_data) # return super().create(validated_data) def update(self, instance, validated_data): print(instance) print(validated_data) # 保存数据 # self.child:是BookModelSerializer对象 # ll=[] # for i,si_data in enumerate(validated_data): # ret=self.child.update(instance[i],si_data) # ll.append(ret) # return ll return [ # self.child.update(对象,字典) for attrs in validated_data self.child.update(instance[i],attrs) for i,attrs in enumerate(validated_data) ] #如果序列化的是数据库的表,尽量用ModelSerializer class BookModelSerializer(serializers.ModelSerializer): # 一种方案(只序列化可以,反序列化有问题) # publish=serializers.CharField(source='publish.name') # 第二种方案,models中写方法 class Meta: list_serializer_class=BookListSerializer model=models.Book # fields='__all__' # 用的少 # depth=0 fields = ('name','price','authors','publish','publish_name','author_list') extra_kwargs={ 'publish':{'write_only':True}, 'publish_name':{'read_only':True}, 'authors':{'write_only':True}, 'author_list':{'read_only':True} }
views.py
# views.py from rest_framework.response import Response from api import models from rest_framework.views import APIView from rest_framework.generics import GenericAPIView from api.ser import BookModelSerializer class BookAPIView(APIView): def get(self,request,*args,**kwargs): #查询单个和查询所有,合到一起 # 查所有 book_list=models.Book.objects.all().filter(is_delete=False) book_list_ser=BookModelSerializer(book_list,many=True) return Response(data=book_list_ser.data) #查一个 def post(self,request,*args,**kwargs): # 具备增单条,和增多条的功能 if isinstance(request.data,dict): book_ser=BookModelSerializer(data=request.data) book_ser.is_valid(raise_exception=True) book_ser.save() return Response(data=book_ser.data) elif isinstance(request.data,list): #现在book_ser是ListSerializer对象 from rest_framework.serializers import ListSerializer book_ser = BookModelSerializer(data=request.data,many=True) #增多条 print('--------',type(book_ser)) book_ser.is_valid(raise_exception=True) book_ser.save() # 新增---》ListSerializer--》create方法 # def create(self, validated_data): # self.child是BookModelSerializer对象 # print(type(self.child)) # return [ # self.child.create(attrs) for attrs in validated_data # ] return Response(data=book_ser.data) def put(self,request,*args,**kwargs): # 改一个,改多个 #改一个个 if kwargs.get('pk',None): book=models.Book.objects.filter(pk=kwargs.get('pk')).first() book_ser = BookModelSerializer(instance=book,data=request.data,partial=True) # 增多条 book_ser.is_valid(raise_exception=True) book_ser.save() return Response(data=book_ser.data) else: #改多个, # 前端传递数据格式[{id:1,name:xx,price:xx},{id:1,name:xx,price:xx}] # 处理传入的数据 对象列表[book1,book2] 修改的数据列表[{name:xx,price:xx},{name:xx,price:xx}] book_list=[] modify_data=[] for item in request.data: #{id:1,name:xx,price:xx} pk=item.pop('id') book=models.Book.objects.get(pk=pk) book_list.append(book) modify_data.append(item) # 第一种方案,for循环一个一个修改 #把这个实现 # for i,si_data in enumerate(modify_data): # book_ser = BookModelSerializer(instance=book_list[i], data=si_data) # book_ser.is_valid(raise_exception=True) # book_ser.save() # return Response(data='成功') # 第二种方案,重写ListSerializer的update方法 book_ser = BookModelSerializer(instance=book_list,data=modify_data,many=True) book_ser.is_valid(raise_exception=True) book_ser.save() #ListSerializer的update方法,自己写的update方法 return Response(book_ser.data) # request.data # # book_ser=BookModelSerializer(data=request.data) def delete(self,request,*args,**kwargs): #单个删除和批量删除 pk=kwargs.get('pk') pks=[] if pk: # 单条删除 pks.append(pk) #不管单条删除还是多条删除,都用多条删除 #多条删除 # {'pks':[1,2,3]} else: pks=request.data.get('pks') #把is_delete设置成true # ret返回受影响的行数 ret=models.Book.objects.filter(pk__in=pks,is_delete=False).update(is_delete=True) if ret: return Response(data={'msg':'删除成功'}) else: return Response(data={'msg': '没有要删除的数据'})
urls.py
# urls.py from django.urls import path,re_path from api import views urlpatterns = [ path('books/', views.BookAPIView.as_view()), re_path('books/(?P<pk>\d+)', views.BookAPIView.as_view()), ]
# 查所有,才需要分页 from rest_framework.generics import ListAPIView # 内置三种分页方式 from rest_framework.pagination import PageNumberPagination,LimitOffsetPagination,CursorPagination ''' PageNumberPagination page_size:每页显示的条数 '''
# 第一种分页 from rest_framework.pagination import PageNumberPagination,LimitOffsetPagination,CursorPagination
class MyPageNumberPagination(PageNumberPagination): #http://127.0.0.1:8000/api/books2/?aaa=1&size=6 page_size=3 #每页条数 page_query_param='aaa' #查询第几页的key page_size_query_param='size' # 可以在前端通过size=xxx控制每一页显示的条数 max_page_size=5 # 每页最大显示条数 class BookView(ListAPIView): # queryset = models.Book.objects.all().filter(is_delete=False) queryset = models.Book.objects.all() serializer_class = BookModelSerializer #配置分页 pagination_class = MyPageNumberPagination
二、标杆分页
# 第二种分页 from rest_framework.pagination import PageNumberPagination,LimitOffsetPagination,CursorPagination class MyLimitOffsetPagination(LimitOffsetPagination): default_limit = 3 # 每页条数 limit_query_param = 'limit' # 往后拿几条 offset_query_param = 'offset' # 标杆 max_limit = 5 # 每页最大几条 class BookView(ListAPIView): # queryset = models.Book.objects.all().filter(is_delete=False) queryset = models.Book.objects.all() serializer_class = BookModelSerializer #配置分页 pagination_class = MyLimitOffsetPagination
三、排序分页
# 第三种分页 from rest_framework.pagination import PageNumberPagination,LimitOffsetPagination,CursorPagination class MyCursorPagination(CursorPagination): cursor_query_param = 'cursor' # 每一页查询的key page_size = 2 #每页显示的条数 ordering = '-id' #排序字段 class BookView(ListAPIView): # queryset = models.Book.objects.all().filter(is_delete=False) queryset = models.Book.objects.all() serializer_class = BookModelSerializer #配置分页 pagination_class = MyCursorPagination
如果继承APIView/GenericAPIView类的分页使用
# 如果使用APIView/GenericAPIView分页 from rest_framework.pagination import PageNumberPagination,LimitOffsetPagination,CursorPagination from utils.throttling import MyThrottle class MyPageNumberPagination(PageNumberPagination): page_size=1 #每页条数 page_query_param='page' #查询第几页的key page_size_query_param='size' # 可以在前端通过size=xxx控制每一页显示的条数 max_page_size=5 # 每页最大显示条数 class BookView(APIView): # throttle_classes = [MyThrottle,]
def get(self,request,*args,**kwargs): book_list=models.Book.objects.all()
# 实例化得到一个分页器对象 page_cursor=MyPageNumberPagination() book_list=page_cursor.paginate_queryset(book_list,request,view=self) next_url =page_cursor.get_next_link() # 需要return才会显示 pr_url=page_cursor.get_previous_link() # 需要return才会显示 # print(next_url) # print(pr_url) book_ser=BookModelSerializer(book_list,many=True) return Response({'data':book_ser.data, 'next':next_url,'pre': pre_url}) #settings.py REST_FRAMEWORK={ 'PAGE_SIZE': 2, }
# 写一个类,继承SimpleRateThrottle,只需要重写get_cache_key from rest_framework.throttling import SimpleRateThrottle #继承SimpleRateThrottle class MyThrottle(SimpleRateThrottle): scope='luffy' def get_cache_key(self, request, view): print(request.META.get('REMOTE_ADDR')) return request.META.get('REMOTE_ADDR') # 返回 # 局部使用,全局使用 REST_FRAMEWORK={ 'DEFAULT_THROTTLE_CLASSES': ( 'utils.throttling.MyThrottle', ), 'DEFAULT_THROTTLE_RATES': { 'luffy': '3/m' # key要跟类中的scop对应 }, } # python3 manage.py runserver 0.0.0.0:8000 你们局域网就可以相互访问 # 内网穿透
总结
#1 book 其实是5个表(自动生成了一个), -一对一关系,其实是Forainkey,unique -on_delete:级联删除,设置为空,什么都不干,设置成默认值 -字段建索引,字段唯一 -联合索引,联合唯一 -日期类型 auto_now 和 auto_now_add -基表 abstract #2 book -单条查询,多条查询 -单条增,多条增(生成序列化对象,many=True) -单条修改,多条修改(BookListSerializer:重写了update方法) -单删,群删(is_delete),统一用群删 pk__in=[1,2,3] # 3 频率 -自定义频率(ip,user_id) -继承SimpleRateThrottle -重写get_cache_key,返回什么就以什么为key进行限制 -scope字段,需要与setting中对应 #4 分页 -PageNumberPagination,基本分页 # page_size-每页显示大小 # page_query_param-get请求路径中查询的key # page_size_query_param-前端控制get请求路径中每页显示条数 # max_page_size-每页最大显示多少条 -LimitOffsetPagination,偏移量分页 # default_limit = 3 # 每页条数 # limit_query_param = 'limit' # 往后拿几条 # offset_query_param = 'offset' # 标杆 # max_limit = 5 # 每页最大几条 -CursorPagination,游标分页 # cursor_query_param = 'cursor' # 每一页查询的key # page_size = 2 #每页显示的条数 # ordering = '-id' #排序字段-
# 自定制频率类,需要写两个方法 -# 判断是否限次:没有限次可以请求True,限次了不可以请求False def allow_request(self, request, view): -# 限次后调用,显示还需等待多长时间才能再访问,返回等待的时间seconds def wait(self): # 代码 import time class IPThrottle(): #定义成类属性,所有对象用的都是这个 VISIT_DIC = {} def __init__(self): self.history_list=[] def allow_request(self, request, view): ''' #(1)取出访问者ip #(2)判断当前ip不在访问字典里,添加进去,并且直接返回True,表示第一次访问,在字典里,继续往下走 #(3)循环判断当前ip的列表,有值,并且当前时间减去列表的最后一个时间大于60s,把这种数据pop掉,这样列表中只有60s以内的访问时间, #(4)判断,当列表小于3,说明一分钟以内访问不足三次,把当前时间插入到列表第一个位置,返回True,顺利通过 #(5)当大于等于3,说明一分钟内访问超过三次,返回False验证失败 ''' ip=request.META.get('REMOTE_ADDR') ctime=time.time() if ip not in self.VISIT_DIC: self.VISIT_DIC[ip]=[ctime,] return True self.history_list=self.VISIT_DIC[ip] #当前访问者时间列表拿出来 while True: if ctime-self.history_list[-1]>60: self.history_list.pop() # 把最后一个移除 else: break if len(self.history_list)<3: self.history_list.insert(0,ctime) return True else: return False def wait(self): # 当前时间,减去列表中最后一个时间 ctime=time.time() return 60-(ctime-self.history_list[-1]) #全局使用,局部使用
# SimpleRateThrottle源码分析 def get_rate(self): """ Determine the string representation of the allowed request rate. """ if not getattr(self, 'scope', None): msg = ("You must set either `.scope` or `.rate` for '%s' throttle" % self.__class__.__name__) raise ImproperlyConfigured(msg) try: return self.THROTTLE_RATES[self.scope] # scope:'user' => '3/min' 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) #3 mmmmm num, period = rate.split('/') # rate:'3/min' num_requests = int(num) duration = {'s': 1, 'm': 60, 'h': 3600, 'd': 86400}[period[0]] return (num_requests, duration) def allow_request(self, request, view): if self.rate is None: return True #当前登录用户的ip地址 self.key = self.get_cache_key(request, view) # key:'throttle_user_1' if self.key is None: return True # 初次访问缓存为空,self.history为[],是存放时间的列表 self.history = self.cache.get(self.key, []) # 获取一下当前时间,存放到 self.now self.now = self.timer() # Drop any requests from the history which have now passed the # throttle duration # 当前访问与第一次访问时间间隔如果大于60s,第一次记录清除,不再算作一次计数 # 10 20 30 40 # self.history:[10:23,10:55] # now:10:56 while self.history and self.now - self.history[-1] >= self.duration: self.history.pop() # history的长度与限制次数3进行比较 # history 长度第一次访问0,第二次访问1,第三次访问2,第四次访问3失败 if len(self.history) >= self.num_requests: # 直接返回False,代表频率限制了 return self.throttle_failure() # history的长度未达到限制次数3,代表可以访问 # 将当前时间插入到history列表的开头,将history列表作为数据存到缓存中,key是throttle_user_1,过期时间60s return self.throttle_success()
# 1 安装:pip install coreapi # 2 在总路由中配置 from rest_framework.documentation import include_docs_urls urlpatterns = [ ... path('docs/', include_docs_urls(title='站点页面标题')) ] #3 视图类:自动接口文档能生成的是继承自APIView及其子类的视图。 -1 ) 单一方法的视图,可直接使用类视图的文档字符串,如 class BookListView(generics.ListAPIView): """ 返回所有图书信息. """ -2)包含多个方法的视图,在类视图的文档字符串中,分开方法定义,如 class BookListCreateView(generics.ListCreateAPIView): """ get: 返回所有图书信息. post: 新建图书. """ -3)对于视图集ViewSet,仍在类视图的文档字符串中封开定义,但是应使用action名称区分,如 class BookInfoViewSet(mixins.ListModelMixin, mixins.RetrieveModelMixin, GenericViewSet): """ list: 返回图书列表数据 retrieve: 返回图书详情数据 latest: 返回最新的图书数据 read: 修改图书的阅读量 """ -4)基于APIView的接口,定义在对应的方法下面,如: class BookAPIView(APIView): def get(self, request, *args, **kwargs): ''' get查所有的接口文档 ''' book = models.Book.objects.all() book_ser = BookModelSerializer(instance=book, many=True) return Response(book_ser.data) def post(self, request, *args, **kwargs): ''' post添加数据接口 ''' book = models.Book.objects.all() book_ser = BookModelSerializer(instance=book, data=request.data) if book_ser.is_valid(): book_ser.save() return Response(book_ser.data) 如果进入docs报了下面的错误,说明我们缺少一个依赖, 'AutoSchema' object has no attribute 'get_link'
只需要在setting中配置如下: REST_FRAMEWORK = { 'DEFAULT_SCHEMA_CLASS': 'rest_framework.schemas.AutoSchema', } 两点说明: 1) 视图集ViewSet中的retrieve名称,在接口文档网站中叫做read 2)参数的Description需要在模型类或序列化器类的字段中以help_text选项定义,如: class Student(models.Model): ... age = models.IntegerField(default=0, verbose_name='年龄', help_text='年龄') ...
注意,如果你多个应用使用同一个序列化器,可能会导致help_text的内容显示有些问题,小事情 class StudentSerializer(serializers.ModelSerializer): class Meta: model = Student fields = "__all__" extra_kwargs = { 'age': { 'required': True, 'help_text': '年龄' } }
详情见drf自动生成API文档
jwt=Json Web token #原理 """ 1)jwt分三段式:头.体.签名 (head.payload.sgin) 2)头和体是可逆加密,让服务器可以反解出user对象;签名是不可逆加密,保证整个token的安全性的 3)头体签名三部分,都是采用json格式的字符串,进行加密,可逆加密一般采用base64算法,不可逆加密一般采用hash(md5)算法 4)头中的内容是基本信息:公司信息、项目组信息、token采用的加密方式信息 { "company": "公司信息", ... } 5)体中的内容是关键信息:用户主键、用户名、签发时客户端信息(设备号、地址)、过期时间 { "user_id": 1, ... } 6)签名中的内容时安全信息:头的加密结果 + 体的加密结果 + 服务器不对外公开的安全码 进行md5加密 { "head": "头的加密字符串", "payload": "体的加密字符串", "secret_key": "安全码" } """ 校验 """ 1)将token按 . 拆分为三段字符串,第一段 头加密字符串 一般不需要做任何处理 2)第二段 体加密字符串,要反解出用户主键,通过主键从User表中就能得到登录用户,过期时间和设备信息都是安全信息,确保token没过期,且时同一设备来的 3)再用 第一段 + 第二段 + 服务器安全码 不可逆md5加密,与第三段 签名字符串 进行碰撞校验,通过后才能代表第二段校验得到的user对象就是合法的登录用户 """ drf项目的jwt认证开发流程(重点) """ 1)用账号密码访问登录接口,登录接口逻辑中调用 签发token 算法,得到token,返回给客户端,客户端自己存到cookies中 2)校验token的算法应该写在认证类中(在认证类中调用),全局配置给认证组件,所有视图类请求,都会进行认证校验,所以请求带了token,就会反解出user对象,在视图类中用request.user就能访问登录的用户 注:登录接口需要做 认证 + 权限 两个局部禁用 """ # 第三方写好的 django-rest-framework-jwt # 安装pip install djangorestframework-jwt # 新建一个项目,继承AbstractUser表() # 创建超级用户 # 简单使用 #urls.py from rest_framework_jwt.views import ObtainJSONWebToken,VerifyJSONWebToken,RefreshJSONWebToken,obtain_jwt_token path('login/', obtain_jwt_token),
# 1 控制用户登录后才能访问,和不登录就能访问 from rest_framework.permissions import IsAuthenticated class OrderAPIView(APIView):# 登录才能 authentication_classes = [JSONWebTokenAuthentication,] # 权限控制 permission_classes = [IsAuthenticated,] def get(self,request,*args,**kwargs): return Response('这是订单信息') class UserInfoAPIView(APIView):# 不登录就可以 只需要去除权限控制 authentication_classes = [JSONWebTokenAuthentication,] # 权限控制 # permission_classes = [IsAuthenticated,] def get(self,request,*args,**kwargs): return Response('UserInfoAPIView')
# 2 控制登录接口返回的数据格式 -第一种方案,自己写登录接口 -第二种写法,用内置,控制登录接口返回的数据格式 -jwt的settings.py中有这个属性 'JWT_RESPONSE_PAYLOAD_HANDLER':'rest_framework_jwt.utils.jwt_response_payload_handler', -重写jwt_response_payload_handler,配置成咱们自己的
# 方式一:基于BaseAuthentication from rest_framework.authentication import BaseAuthentication from rest_framework.exceptions import AuthenticationFailed from rest_framework_jwt.authentication import jwt_decode_handler import jwt from api import models class MyJwtAuthentication(BaseAuthentication): def authenticate(self, request): jwt_value=request.META.get('HTTP_AUTHORIZATION') # 获取前端token if jwt_value: try: #jwt提供了通过三段token,取出payload的方法,并且有校验功能 payload=jwt_decode_handler(jwt_value) # 通过token反解出payload except jwt.ExpiredSignature: raise AuthenticationFailed('签名过期') except jwt.InvalidTokenError: raise AuthenticationFailed('用户非法') except Exception as e: # 所有异常都会走到这 raise AuthenticationFailed(str(e)) # 因为payload就是用户信息的字典 print(payload) # return payload, jwt_value # 需要得到user对象, # 第一种,payload中包含用户信息 # 通过payload中提取的数据去数据库校验用户是否存在 # user=models.User.objects.get(pk=payload.get('user_id')) # 第二种不查库 user=models.User(id=payload.get('user_id'),username=payload.get('username')) return user,jwt_value # 没有值,直接抛异常 raise AuthenticationFailed('您没有携带认证信息') # 方式二:基于BaseJSONWebTokenAuthentication from rest_framework_jwt.authentication import BaseJSONWebTokenAuthentication from rest_framework.exceptions import AuthenticationFailed from rest_framework_jwt.authentication import jwt_decode_handler import jwt class MyJwtAuthentication(BaseJSONWebTokenAuthentication): def authenticate(self, request): jwt_value=request.META.get('HTTP_AUTHORIZATION') if jwt_value: try: #jwt提供了通过三段token,取出payload的方法,并且有校验功能 payload=jwt_decode_handler(jwt_value) except jwt.ExpiredSignature: raise AuthenticationFailed('签名过期') except jwt.InvalidTokenError: raise AuthenticationFailed('用户非法') except Exception as e: # 所有异常都会走到这 raise AuthenticationFailed(str(e)) # self.authenticate_credentials本质也是查数据库 user=self.authenticate_credentials(payload) return user,jwt_value # 没有值,直接抛异常 raise AuthenticationFailed('您没有携带认证信息') ''' jwt_payload_handler = api_settings.JWT_PAYLOAD_HANDLER jwt_encode_handler = api_settings.JWT_ENCODE_HANDLER payload = jwt_payload_handler(user) # 把user传入,得到payload token = jwt_encode_handler(payload) # 把payload传入,得到token '''
# 使用用户名,手机号,邮箱,都可以登录# # 前端需要传的数据格式 { "username":"lqz/1332323223/33@qq.com", "password":"lqz12345" } # views.py 视图类 from rest_framework.views import APIView from rest_framework.viewsets import ViewSetMixin, ViewSet from app02 import ser class Login2View(ViewSet): # 跟上面完全一样 def login(self, request, *args, **kwargs): # 1 需要 有个序列化的类 login_ser = ser.LoginModelSerializer(data=request.data,context={'request':request}) # 2 生成序列化类对象 # 3 调用序列号对象的is_validad login_ser.is_valid(raise_exception=True) token=login_ser.context.get('token') # 4 return return Response({'status':100,'msg':'登录成功','token':token,'username':login_ser.context.get('username')})
# ser.py 序列化类
from rest_framework import serializers from api import models import re from rest_framework.exceptions import ValidationError from rest_framework_jwt.utils import jwt_encode_handler,jwt_payload_handler class LoginModelSerializer(serializers.ModelSerializer): username=serializers.CharField() # 重新覆盖username字段,数据中它是unique唯一,post请求认为你在新增数据,校验会不通过 class Meta: model=models.User fields=['username','password'] def validate(self, attrs): print(self.context) # 在这写逻辑 username=attrs.get('username') # 用户名有三种方式 password=attrs.get('password') # 通过判断,username数据不同,查询字段不一样 # 正则匹配,如果是手机号 if re.match('^1[3-9][0-9]{9}$',username): user=models.User.objects.filter(mobile=username).first() elif re.match('^.+@.+$',username):# 邮箱 user=models.User.objects.filter(email=username).first() else: user=models.User.objects.filter(username=username).first() if user: # 存在用户 # 校验密码,因为是密文,要用check_password if user.check_password(password): # 签发token payload = jwt_payload_handler(user) # 把user传入,得到payload token = jwt_encode_handler(payload) # 把payload传入,得到token self.context['token']=token self.context['username']=user.username return attrs else: raise ValidationError('密码错误') else: raise ValidationError('用户不存在')
# settings.py
# jwt的配置 import datetime JWT_AUTH={ 'JWT_RESPONSE_PAYLOAD_HANDLER':'app02.utils.my_jwt_response_payload_handler', 'JWT_EXPIRATION_DELTA': datetime.timedelta(days=7), # 过期时间,手动配置 }
# RBAC :是基于角色的访问控制(Role-Based Access Control ),公司内部系统 # django的auth就是内置了一套基于RBAC的权限系统 # django中 # 后台的权限控制(公司内部系统,crm,erp,协同平台) user表 permssion表 group表 user_groups表是user和group的中间表 group_permissions表是group和permssion中间表 user_user_permissions表是user和permission中间表 # 前台(主站),需要用三大认证 # 演示:
# 前端混合开发缓存的使用 -缓存的位置,通过配置文件来操作(以文件为例) -缓存的粒度: -全站缓存 中间件 MIDDLEWARE = [ 'django.middleware.cache.UpdateCacheMiddleware', 。。。。 'django.middleware.cache.FetchFromCacheMiddleware', ] CACHE_MIDDLEWARE_SECONDS=10 # 全站缓存时间 -单页面缓存 在视图函数上加装饰器 from django.views.decorators.cache import cache_page @cache_page(5) # 缓存5s钟 def test_cache(request): import time ctime=time.time() return render(request,'index.html',context={'ctime':ctime}) -页面局部缓存 {% load cache %} {% cache 5 'name' %} # 5表示5s钟,name是唯一key值 {{ ctime }} {% endcache %} # 前后端分离缓存的使用 - 如何使用 from django.core.cache import cache cache.set('key',value可以是任意数据类型) cache.get('key') -应用场景: -第一次查询所有图书,你通过多表联查序列化之后的数据,直接缓存起来 -后续,直接先去缓存查,如果有直接返回,没有,再去连表查,返回之前再缓存
# base64编码和解码 #md5固定长度,不可反解 #base63 变长,可反解 #编码(字符串,json格式字符串) import base64 import json dic={'name':'lqz','age':18,'sex':'男'} dic_str=json.dumps(dic) ret=base64.b64encode(dic_str.encode('utf-8')) print(ret) # 解码 # ret是带解码的串 ret2=base64.b64decode(ret) print(ret2)
整体总结
# 1 restful规范--10条 # 2 django上写符合restful规范的接口 # 3 drf写接口 # 4 APIView--》继承了原生View---》get,post方法 -(为什么get请求来了,就会执行get方法:原生View的dispatch控制的) -路由配置:视图类.as_view()---->view(闭包函数)的内存地址 -请求来了,就会执行view(requst,分组分出的字段,默认传的字段)---》self.dispatch()-->处理的 -APIView重写了dispatch:包装了request对象,解析器,分页,三大认证,响应器,全局异常,去掉了csrf # 5 Request对象:request._request,request.data,重写了__getattr__,request.method-->去原生request中拿 -前端传过来的数据从那取? -地址栏里:request.GET/query_params -请求体中的数据:request.data/POST(json格式解释不了)---》request.body中取 -请求头中数据:request.META.get("HTTP_变成大写") #6 Response对象---》封装了原生的HttpResponse,Response(data,headers={},status=1/2/3/4/5开头的) #7 自己封装了Response对象 # 8 序列化类: -Serializer -写字段,字段名要跟表的字段对应,想不对应(source可以修改),有属性,read_only,max_len... -SerializerMethodField必须配套一个get_字段名,返回什么,前台就看到什么 -ModelSerializer -class Meta: 表对应 取出的字段(__all__,列表) 排除的字段(用的很少) extra_kwargs会给字段的属性 -重写某个字段 password=serializers.SerializerMethodField() def get_password(self,instance): return "***" -校验:字段自己的校验,局部钩子,全局钩子 -只要序列化类的对象执行了is_valiad(),这些钩子都会走,可以再钩子里写逻辑 -在表模型(model)中写方法,可以在上面取出的字段中直接写,不参与反序列化 -序列化多条(many=True):本质,ListSerializer内部套了一个个的serializer对象 -重写ListSerializer,让序列化对象和自己写的ListSerializer对应上(了解) -序列化类(instance,data,many,context={requtst:request}) -视图函数中给序列化对象传递数据,使用context,传回来,放进去直接使用序列化对象.context.get() # 9 视图 -两个视图基类 APIView,GenericAPIView(继承APIView):涉及到数据库和序列化类的操作,尽量用GenericAPIView -5个视图扩展类(父类都是object) CreateModelMixin:create DestroyModelMixin:destory ListModelMixin RetrieveModelMixin UpdateModelMixin -9个视图子类(GenericAPIView+上面5个视图扩展类中的一个或多个) RetrieveUpdateDestroyAPIView CreateAPIView RetrieveAPIView DestroyAPIView RetrieveUpdateAPIView ListCreateAPIView UpdateAPIView ListAPIView RetrieveDestroyAPIView -视图集 -ModelViewSet:5大接口都有了 -ReadOnlyModelViewSet:获取一条和获取多条的接口 -GenericViewSet:ViewSetMixin+GenericAPIView ViewSet:ViewSetMixin+APIView ViewSetMixin:类重写了as_view,路由配置就变样了 # 10 路由 -基本配置:跟之前一样 -有action的:必须继承ViewSetMixin -自动生成:DefaultRouter和SimpleRouter -导入,实例化得到对象,注册多个,对象.urls(自动生成的路由) -路由相加urlpatterns+=router.urls/include:path('', include(router.urls)) -视图类中自己定义的方法,如何自动生成路由 -在自己定义的方法上加装饰器(action) -两个参数methods=[GET,POST],表示这两种请求都能接受 -两个参数detail=True,表示生成带pk的连接 # 11 三大认证 -认证组件:校验用户是否登录 -写一个认证类,继承BaseAuthentication,重写authenticate,内部写认证逻辑,认证通过返回两个值,第一个是user,认证失败,抛去异常 -全局使用,局部使用,局部禁用 -权限:校验用户是否有权限进行后续操作 -写一个类,继承BasePermission,重写has_permission,True和False -全局使用,局部使用,局部禁用 -频率:限制用户访问频次 -写一个类,继承SimpleRateThrottle,重写get_cache_key,返回什么,就以谁做限制,scop=luffy字段,需要跟setting中的key对应 luffy:3/h(一小时访问三次) -全局配置,局部配置,局部禁用 -需求:发送短信验证码的接口,一分钟只能发送一次,局部使用,配在视图类上 # 12 解析器:前端传的编码格式,能不能解析(默认三种全配了,基本不需要改),可能你写了个上传文件接口,局部配置一下,只能传form-data格式 局部使用:MultiPartParser # 13 响应器:响应的数据,是json格式还是带浏览器的那种(不需要配) # 14 过滤器:借助于第三方django-filter -注册应用 -setting中配置DjangoFilterBackend或者局部配置 -filter_fields = ('age', 'sex') # 15 排序 -全局或者局部配置rest_framework.filters.OrderingFilter -视图类中配置: ordering_fields = ('id', 'age') # 16 分页 -使用: 继承了APIView的视图类中使用 page=Mypage() # 在数据库中获取分页的数据 page_list=page.paginate_queryset(queryset对象,request,view=self) # 对分页进行序列化 ser=BookSerializer1(instance=page_list,many=True) # return Response(ser.data) 继承了视图子类的视图中使用 pagination_class = PageNumberPagination(配置成自己重写的,可以修改字段) -CursorPagination cursor_query_param:默认查询字段,不需要修改 page_size:每页数目 ordering:按什么排序,需要指定 -LimitOffsetPagination default_limit 默认限制,默认值与PAGE_SIZE设置一直 limit_query_param limit参数名,默认’limit’ offset_query_param offset参数名,默认’offset’ max_limit 最大limit限制,默认None -PageNumberPagination:最常用的,需要在setting中配置page_size,四个参数 page_size 每页数目 page_query_param 前端发送的页数关键字名,默认为”page” page_size_query_param 前端发送的每页数目关键字名,默认为None max_page_size 前端最多能设置的每页数量 # 17 全局异常 -写一个方法 def exception_handler(exc, context): # 走drf原来的异常,原理异常有一些处理 response = drf_exception_handler(exc, context) # 我们自己处理,drf没有处理,丢给django的异常 if response is None: if isinstance(exc, DatabaseError):#处理了一下数据库错误 response = Response({'detail': '数据库错误'}, status=status.HTTP_507_INSUFFICIENT_STORAGE) else:#其他异常 response = Response({'detail': '未知错误'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR) return response -配置文件中配置(以后所有drf的异常,都会走到这里) REST_FRAMEWORK = { 'EXCEPTION_HANDLER': 'my_project.my_app.utils.custom_exception_handler' } -18 jwt -是什么json web token 新的认证方式 -三段:头,荷载(用户信息),签名 -使用:最简单方式(在路由中配置) -path('login/', obtain_jwt_token), -自定制: 多方式登录,手动签发token(两个方法) -自定制基于jwt的认证类 -取出token -调用jwt提供的解析出payload的方法(校验是否过期,是否合法,如果合法,返回荷载信息) -转成user对象 -返回 -19 RBAC:基于角色的权限控制(django默认的auth就是给你做了这个事),公司内部权限管理 对外的权限管理就是用三大认证 -用户表 -用户组表 -权限表 -用户对用户组中间表 -用户组对权限中间表 -用户对权限中间表