Django-Rest-Framework
#前后端混合开发（前后端不分离）：返回的是html的内容，需要写模板 #前后端分离：只专注于写后端接口，返回json，xml格式数据 # 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） #页面静态化 lqz
#通过网络，规定了前后台信息交互规则的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. 序列化,序列化器会把模型对象转换成字典,经过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\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\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\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)) #print(type(book_one_ser)) # # 对象的生成--》先调用类的__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表模型中的方法
这里需要注意：
要是字段中用了source参数，就在后面的update/局部钩子/全局钩子中，如果使用到该字段校验，
必须使用source指定的参数作为值，否则会出错
# SerializerMethodField(）的使用 1 它需要有个配套方法，方法名叫get_字段名，返回值就是要显示的东西 authors=serializers.SerializerMethodField() #它需要有个配套方法，方法名叫get_字段名，返回值就是要显示的东西 def get_authors(self,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')
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\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\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\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\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\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'})),
补充
在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\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\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 #^books/(?P[^/.]+)/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()
# 写一个认证类 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