上周回顾
# 1 前端开发模式
-分离和混合
-http 通信 后端都是web后端
-前端:pc桌面开发,web开发,app,小程序--->http--->调用后端--->后端都是一套
# 2 api接口
-前后端交互的媒介
url地址:
https://api.map.baidu.com
请求方式:
get,post,put,patch,delete
606-331-199请求参数:
json格式的key-value类型数据
响应结果:
json格式数据
# 3 接口测试工具 postman
# 4 restful规范
1.数据的安全保障 通常使用https协议
2.接口中带api标识
3.多版本共存 路径中带版本信息
4.数据即是资源 均使用名词 尽量不出现动词
5.资源操作由请求方式决定(method)
6.在请求地址带过滤条件
7.响应状态码:两套
http响应状态码:1xx 请求正在处理 2xx 成功响应 3xx 重定向 4xx 客户端错误 5xx 服务端错误
8.返回数据中带错误信息
9.返回结果应该符合以下规范
GET 获取所有数据:返回资源对象的列表(数组)[{name:红楼梦,price:99},{name:红楼梦,price:99},{name:红楼梦,price:99}]
GET 单个对象:返回单个资源对象:{name:红楼梦,price:99}
POST 新增对象:返回新生成的资源对象:{name:西游记,price:99}
PUT 修改对象:返回完整的资源对象 :{name:西游记,price:100}
DELETE 删除:返回一个空文档
10.响应数据中带连接
# 5 drf介绍,快速使用
# 6 cbv 执行流程
# 7 APIView执行流程
# 8 Request对象源码
# 9 序列化反序列化
序列化:把我们识别的数据转换成指定格式提供给别人
反序列化:把别人提供的数据转换/还原成我们需要的格式
# 10 序列化组件--->写继承类 实例化得到对象
-常用字段和字段参数
-做序列化
-序列化类实例化--->对象--->传入要序列化的数据 many--->ser.data
-source
-SerializerMethodField
-在表模型中写方法
-ListField
-DictField
-做反序列化
-新增
-序列化类实例化--->对象--->传入前端的数据--->数据校验--->ser.save
-保存
-序列化类实例化--->对象--->传入前端的数据和要修改的数据--->数据校验--->ser.save
-数据校验:字段自己,局部,全局钩子
-重点:
有时候,序列化字段和反序列化字段,不一样
-定制的序列化字段,不能用来反
-read_only和write_only 的使用
-数据校验
-字段自己
-局部
-全局
-ModelSerializer,跟表有关系
-不用重写create和update
-字段可以映射过来
-重写字段
-给字段类传参数--->extra_kwargs
-定制字段,跟之前一摸一样
-fields 列表,必须要有所有字段(序列化,反序列化都要注册--->一定是表模型的字段吗?)
# 11 请求与响应
-Request 源码
-能够解析的编码格式
-全局配置
-局部配置
-Response 源码
-能够响应的编码格式
-全局
-局部
-drf向响应头中写数据
-原生django向响应头中写数据
obj=HttpResponse() --->obj['xx']=yy
# 12 视图 View
-两个视图基类:APIView GenericAPIView
-APIView
-执行流程:新的reqeust,三大认证,全局异常
-重写了as_view,dispatch
-类属性:parser_class,xxx
-GenericAPIView---》继承了APIView----》以后,如果是跟数据库打交道,尽量用它
1 queryset:要序列化或反序列化的表模型数据
2 serializer_class:使用的序列化类
3 lookup_field :查询单条的路由分组分出来的字段名
4 filter_backends:过滤类的配置(了解)
5 pagination_class:分页类的配置(了解)
# 方法
1 get_queryset :获取要序列化的对象
2 get_object :获取单个对象
3 get_serializer :获取序列化类 ,跟它差不多的get_serializer_class,一般重写它,不调用它
4 filter_queryset :过滤有关系(了解)
-补充,根据请求方式,定制序列化类
def get_serializer(self, *args, **kwargs):
if self.request.method=='GET':
return 序列化单条的序列化类
else:
return 新增的序列化类
#13 5 个视图扩展类----》不是视图类----》必须配合GenericAPIView
-每个类自己写了一个方法,写的不是【请求方式,不是put,get。。。】的方法,写的是list,destroy。。。
-minxin 混入,通过多继承来实现多个功能
-from rest_framework.mixins import CreateModelMixin, UpdateModelMixin, DestroyModelMixin, RetrieveModelMixin,
ListModelMixin
-继承GenericAPIView+某个视图扩展类+请求方式的方法
-
drf之视图组件
-
视图集
-
路由系统
-
认证组件
1 drf之视图组件
# 两个视图基类
# 5个视图扩展类
# 9个视图子类---->视图类,不需要额外继承GenericAPIView,只需要继承9个中其中某个,就会有某个或某几个接口
1.1两个视图基类
APIView
导入:from rest_framework.views import APIView
APIView是REST framework提供的所有视图的基类,继承了View父类,对原生request对象进行了封装,并重写了dispatch方法,对认证,权限,频率控制,并处理全局异常
没有操作数据库 需要你自己去写get,post
GenericAPIView
导入:from rest_framework.generics import GenericAPIView
GenericAPIView继承了APIView增加了序列化数据和序列化的类为Mixin扩展类提供支持
常用属性
属性 | 作用 |
---|---|
queryset | 需要序列化的查询集 |
serializer_class | 指定使用的序列化器 |
pagination_class | 分页控制类 |
filter_backends | 过滤控制后端 |
lookup_field | 查询时的查询条件,默认为pk |
常用方法
方法 | 作用 |
---|---|
get_queryset() | 查询获取所有记录 |
get_object() | 获取一条数据对象 |
get_serializer() | 获取配置的序列化类 |
1.2五个视图扩展类
扩展类 | 提供方法 | 用途 |
---|---|---|
ListModelMixin |
list() |
获取多条数据对象 |
CreateModelMixin |
create() |
新增单一数据对象 |
RetrieveModelMixin |
retrieve() |
获取单一数据对象 |
UpdateModelMixin |
update() |
更新一条数据对象 |
DestroyModelMixin |
destroy() |
删除一条数据对象 |
1.3九个子类视图
子类 | 提供方法 | 继承自 |
---|---|---|
CreateAPIView |
提供 post 方法 |
GenericAPIView CreateModelMixin |
ListAPIView |
提供 get 方法 |
GenericAPIView ListModelMixin |
RetireveAPIView |
提供 get 方法 |
GenericAPIView RetrieveModelMixin |
DestoryAPIView |
提供 delete 方法 |
GenericAPIView DestoryModelMixin |
UpdateAPIView |
提供 put 和 patch 方法 |
GenericAPIView UpdateModelMixin |
ListCreateAPIView |
提供 get 、post 方法 |
GenericAPIView ListModelMixin CreateModelMixin |
RetrieveUpdateAPIView |
提供 get 、put 、patch 方法 |
GenericAPIView RetrieveModelMixin UpdateModelMixin |
RetrieveDestroyAPIView |
提供 get 、put 、patch 方法 |
GenericAPIView RetrieveModelMixin DestoryModelMixin |
RetrieveUpdateDestoryAPIView |
提供get 、put 、patch 、delete 方法 |
GenericAPIView RetrieveModelMixin UpdateModelMixin DestoryModelMixin |
# 路由
urlpatterns = [
path('books/', views.BookView.as_view()),
path('books/<int:pk>/', views.BookView.as_view()),
]
# 视图类
from .models import Book
from .serializer import BookSerializer
from rest_framework.generics import ListAPIView, ListCreateAPIView, CreateAPIView, RetrieveAPIView, \
RetrieveUpdateDestroyAPIView, RetrieveDestroyAPIView
class BookView(ListCreateAPIView): # 查询所有,新增一个
queryset = Book.objects.all()
serializer_class = BookSerializer
# 新增一个,修改一个,删除一个
class BookDetailView(RetrieveUpdateDestroyAPIView):
queryset = Book.objects.all()
serializer_class = BookSerializer
2 视图集
2.1 ViewSet
继承 : APIView、 ViewSetMixin
ViewSet视图集类不再实现get()、post()等方法,而是实现动作action如list() 、create() 等
视图集只在使用as_view()方法的时候,才会将action动作与具体请求方式对应上
2.2 ReadOnlyModelViewSet
继承:RetrieveModelMixin、ListModelMixin、GenericViewSet
2.3 ModelViewSet
继承了五个视图扩展类
2.4 通过ReadOnlyModelViewSet编写5个接口
'''
如果两个视图类写成一个 路由会有两个get 路由路径也不一样
drf写了一个类,ModelViewSet,只要继承它,5个接口都有了,但是路由变了
-重点:一旦继承ModelViewSet,路由写法变了---->变成 .as_view({'get': 'list'})
路由做映射,意思是如果get请求,访问这个地址,就执行视图类的list方法
'''
# 路由
urlpatterns = [
path('books/', views.BookView.as_view({'get': 'list', 'post': 'create'})),
path('books/<int:pk>/', views.BookView.as_view({'get': 'retrieve', 'put': 'update', 'delete': 'destroy'})),
]
# 视图类
class BookView(ModelViewSet):
queryset = Book.objects.all()
serializer_class = BookSerializer
2.5 通过ReadOnlyModelViewSet编写2个只读接口
# 路由
urlpatterns = [
path('books/', views.BookView.as_view({'get': 'list'})),
path('books/<int:pk>/', views.BookView.as_view({'get': 'retrieve'})),
]
# 视图类
class BookView(ReadOnlyModelViewSet): # 只有查询所有和查询单个
queryset = Book.objects.all()
serializer_class = BookSerializer
2.6 ViewSetMixin源码分析
# 请求来了,路由匹配成功---》get请求,匹配成功books,会执行 views.BookView.as_view({'get': 'list', 'post': 'create'})()------>读as_view【这个as_view是ViewSetMixin的as_view】
@classonlymethod
def as_view(cls, actions=None, **initkwargs):
# 如果没有传actions,直接抛异常,路由写法变了后,as_view中不传字典,直接报错
if not actions:
raise TypeError("The `actions` argument must be provided when "
"calling `.as_view()` on a ViewSet. For example "
"`.as_view({'get': 'list'})`")
# 。。。。其他代码不用看
def view(request, *args, **kwargs):
self = cls(**initkwargs)
if 'get' in actions and 'head' not in actions:
actions['head'] = actions['get']
self.action_map = actions
for method, action in actions.items():
handler = getattr(self, action)
setattr(self, method, handler)
return self.dispatch(request, *args, **kwargs)
# 去除了csrf校验
return csrf_exempt(view)
# 路由匹配成功执行views.BookView.as_view({'get': 'list', 'post': 'create'})()----》本质执
行ViewSetMixin----》as_view----》内的view()---》代码贴过来
def view(request, *args, **kwargs):
#actions 是传入的字典--->{'get': 'list', 'post': 'create'}
self.action_map = actions
# 第一次循环:method:get,action:list
# 第一次循环:method:post,action:create
for method, action in actions.items():
# 反射:去视图类中反射,action对应的方法,action第一次是list,去视图类中反射list方法
# handler就是视图类中的list方法
handler = getattr(self, action)
# 反射修改:把method:get请求方法,handler:list
# 视图类的对象的get方法,变成了list
setattr(self, method, handler)
return self.dispatch(request, *args, **kwargs) #dispatch是APIView的
# 总结:
-1 只要继承ViewSetMixin的视图类,路由写法就变了(重写了as_veiw)
-2 变成需要需要传入字典映射方法:{'get': 'list', 'post': 'create'}
-只要传入actions,以后访问get就是访问list,访问post,就是访问create
-3 其他执行跟之前一样
-4 以后视图类类中的方法名,可以任意命名,只要在路由中做好映射即可【重要】
2.7 from rest_framework.viewsets包下的类
'''
from rest_framework.viewsets下有这几个类
ModelViewSet:5个试图扩展类+ViewSetMixin+GenericAPIView
ReadOnlyModelViewSet::2个视图扩展类+ViewSetMixin+GenericAPIView 只读的两个
ViewSetMixin:魔法,重新了as_view,只要继承他,以后路由写法变成了映射方法
ViewSet:ViewSetMixin+ APIView
GenericViewSet:ViewSetMixin + GenericAPIView
'''
#重点:
以后,你想继承APIView,但是想变路由写法【视图类中方法名任意命名】,要继承ViewSet
以后,你想继承GenericAPIView,但是想变路由写法【视图类中方法名任意命名】,要继承GenericViewSet
3 视图层大总结
# 1 两个试图基类
-APIView,GenericAPIView
# 2 5个试图扩展类,不是视图类,必须配合GenericAPIView
# 3 9 个视图子类,是视图类,只需要继承其中某一个即可
# 4 视图集
-ModelViewSet:路由写法变了,只需要写两行,5个接口都有了
-ReadOnlyModelViewSet:路由写法变了,只需要写两行,2个只读接口都有了
-ViewSetMixin:不是视图类,魔法,重写了as_view,路由写法变了,变成映射了
views.BookView.as_view({'get': 'list', 'post': 'create'})
-ViewSet:ViewSetMixin + APIView
-GenericViewSet:ViewSetMixin+ GenericAPIView
# 举例子:发送短信接口,视图类叫SendView,方法叫send_sms,路由配置变了
get--->send_sms
class SendView(ViewSet):
def send_sms(self,request):
4 路由系统
4.1 自动生成路由
# drf 由于继承ViewSetMinxin类,路由写法变了
-原生+drf,以后的路由写法,可能会有如下情况(三种情况)
-path('books/',views.BookView.as_view())
-path('books/',views.BookView.as_view({'get':'list','post':'create'}))
-自动生成
# drf提供了两个路由类,继承ModelViewSet后,路由可以自动生成
# 使用步骤
# 第一步:导入路由类
from rest_framework.routers import SimpleRouter
# 第二步:实例化得到对象(两个类,一般使用SimpleRouter)
router = SimpleRouter()
# 第三步:注册
router.register('books', views.BookView, 'books')
# 第四步:在urlpatterns中注册,两种方式
# 方式一:
urlpatterns += router.urls
# 方式二:
导入 from django.urls import path,include
include:path('/api/v1/', include(router.urls)) 方式多一些
from rest_framework.routers import DefaultRouter
# 第二步:
router = DefaultRouter() # 生成多,多了几个:1 Api Root:访问根,可以看到有哪些地址,比如book的,比如publish的
# 底层实现:自动生成路由就是
-本质是自动做映射,能够自动成的前提是,视图类中要有 5个方法的某要给或多个
get--->list
get--->retrieve
put--->update
post--->create
delete--->destory
-ModelViewSet,ReadOnlyModelViewSet可以自动生成
-9个试图子类+配合ViewSetMixin 才可以自动生成
-GenericAPIView+5个试图扩展类+配合ViewSetMixin 才能自动生成
4.2 action 装饰器
# action 写在视图类的方法上,可以自动生成路由
# 使用步骤
写在视图类方法上
class SendView(ViewSet):
@action(methods=['GET'], detail=False, url_path='send_sms', url_name='send_sms')
# methods指定请求方法,可以传多个
# detail:只能传True和False
-False,不带id的路径:send/send_sms/
-True,带id的路径:send/2/send_sms/
#url_path:生成send后路径的名字,默认以方法名命名
# url_name:别名,反向解析使用,了解即可
def send_sms(self, request):
phone = request.query_params.get('phone')
print(f'发送成功{phone}')
return Response({'code': 100, 'msg': '发送成功'})
# 以后看到的drf路由写法
后期,都是自动生成,一般不在urlpatterns 加入路由了
# 补充:
-1 不同请求方式可以使用不同序列化类
-2 不同action使用不同序列化类
class SendView(GenericViewSet):
queryset = None
serializer_class = '序列化类'
def get_serializer(self, *args, **kwargs):
if self.action=='lqz':
return '某个序列化类'
else:
return '另一个序列化列'
@action(methods=['GET'], detail=True)
def send_sms(self, request,pk):
print(pk)
# 手机号,从哪去,假设get请求,携带了参数
phone = request.query_params.get('phone')
print('发送成功,%s' % phone)
return Response({'code': 100, 'msg': '发送成功'})
@action(methods=['GET'], detail=True)
def lqz(self,request): # get
# 序列化类
pass
@action(methods=['GET'], detail=True)
def login(self,request): # get
# 序列化类
pass
5 认证组件
# 访问某个接口,需要登陆后才能访问
# 第一步:写个登录功能,用户表
-User表
-UserToken表:存储用户登录状态 [这个表可以没有,如果没有,把字段直接写在User表上也可以]
5.1 登录接口
#### 表模型
class User(models.Model):
username = models.CharField(max_length=32)
password = models.CharField(max_length=32)
class UserToken(models.Model): # 跟User是一对一
token = models.CharField(max_length=32)
user = models.OneToOneField(to='User', on_delete=models.CASCADE, null=True)
# user :反向,表名小写,所有有user字段
### 路由
router.register('user', views.UserView, 'user') # /api/v1/user/login post 请求
# 视图类
#### 登录接口 自动生成路由+由于登录功能,不用序列化,继承ViewSet
from .models import User, UserToken
import uuid
class UserView(ViewSet):
@action(methods=['POST'], detail=False)
def login(self, request):
username = request.data.get('username')
password = request.data.get('password')
user = User.objects.filter(username=username, password=password).first()
if user:
# 用户存在,登录成功
# 生成一个随机字符串--uuid
token = str(uuid.uuid4()) # 生成一个永不重复的随机字符串
# 在userToken表中存储一下:1 从来没有登录过,插入一条, 2 登录过,修改记录
# 如果有就修改,如果没有就新增 (if 自己写)
# kwargs 传入的东西查找,能找到,使用defaults的更新,否则新增一条
UserToken.objects.update_or_create(user=user, defaults={'token': token})
return Response({'code': '100', 'msg': '登录成功', 'token': token})
else:
return Response({'code': '101', 'msg': '用户名或密码错误'})