web开发模式
# xml,java,python,php,json {"name":"wzh"}
静态页面:没有交互，动态页面:有交互
aip接口
aip:通过网络规定前后台交互规则，前后台信息交互的媒介
Restful规范
#十条规范
1.数据安全保障，https协议
2.接口特征表现，aip接口
3.多版本数据共存
- https://api.baidu.com/v1
- https://api.baidu.com/v2
4.数据就是资源，均使用名词
- https://api.baidu.com/users
- https://api.baidu.com/books
- https://api.baidu.com/book
一般提倡用资源用复数形式
5.资源请求方式决定(method)
操作资源:增删改查
books get:获取所有书
books/1 get请求，获取主键为1的书
books post请求 新增一本书
books/1 put请求，修改主键为1的书
books/1 patch请求，局部修改主键为1的书
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正常响应
200：常规请求
201：创建成功
7.2重定向响应
301：永久重定向
302：暂时重定向
7.3客户端异常
403：请求无权限
404：请求路径不存在
405：请求方法不存在
7.4 服务器异常
500：服务器异常
8.错误处理，应返回错误信息，error当做key
{
error:"无权限操作"
}
9.返回结果，针对不同操作，服务器用户返回结果应该复合以下规范
GET/collection 返回资源对象列表(数组)
GET/collection/resource 返回单个资源对象
POST/collection 返回新生成的资源对象
PUT/collection/resourse 返回完整的资源对象
PATCH/collection/resourse 返回完整的资源对象
DELETE/collection/resourse 返回一个空文档
10.需要url请求资源需要访问的资源请求链接
# Hypermedia API，RESTful API最好做到Hypermedia，即返回结果中提供链接，连向其他API方法，使得用户不查文档，也知道下一步应该做什么
{
"status": 0,
"msg": "ok",
"results":[
{
"name":"肯德基(罗餐厅)",
"img": "https://image.baidu.com/kfc/001.png"
}
...
]
}
drf简单安装和使用
#安装 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.model import Book
class BookModelSerializer(ModelSerializer):
class Meta:
model = Book
fields = "__all__"
4.在视图中写视图类
from rest_framework.viewsets import ModelViewSet
from .moddel import Book
from .ser import BookModelSerializer
class BooksViewSet(ModelViewSet):
queryset = Book.object.all()
serializer_class = BookModelSerializer
5.写路由关系
from app01 import views
from rest_framework.routers import DefaultRouter
router = DefaultRouter() # 可以处理视图的路由器
router.register('book',views.BookViewSet) #向路由器中注册视图集
#将路由器中能够所有路由信息追到django的路由列表
urlpatterns=[
path('admin/',admin.site.urls)
]
urlpatterns += router.urls
6.启动，在postman中测试
cbv源码分析
# 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)
API源码分析
#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)
序列化组件
序列化：序列化器把模型对象转换成字典，经过response以后变成json字符串
反序列化，把客户端发送过来的数据，经过request以后变成字典，序列化器把字典转换成模型
3.反序列化，完成数据校验功能
步骤
1.写一个序列化类，继承Serializer
2.在类中要写序列化字段，想序列化哪个字段，就在类中写哪个字段
3.在视图类中使用，导入，实例化得到序列化对象，把要序列化的对象传入
4.序列化的对象.data1 是一个字典
5.把字典返回，如果不适用rest_framework 提供的Response ，就得使用JsonResonse
# 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()),
序列化组件修改数据
1 写一个序列化的类，继承Serializer
2 在类中写要反序列化的字段，想反序列化哪个字段，就在类中写哪个字段，字段的属性（max_lenth......）
max_length 最大长度
min_lenght 最小长度
allow_blank 是否允许为空
trim_whitespace 是否截断空白字符
max_value 最小值
min_value 最大值
3.在视图类中使用，导入，实例化得到序列化类的对象，把要修改的对象传入，修改数据传入
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()
# 得到一个序列化类的对象
# boo_ser=BookSerializer(book,request.data)
boo_ser=BookSerializer(instance=book,data=request.data)
# 要数据验证（回想form表单的验证）
if boo_ser.is_valid(): # 返回True表示验证通过
boo_ser.save() # 报错
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和write_only
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实际用途
# 序列化多条，需要传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)
Serializer高级用法
#source使用
1.可以该字段名字
xxx=serializers.CharField(source='title')
2.可以跨表
publish=serializers.CharField(source='publish.email')
3.可以执行方法
pub_date = Serializers.CharField(source='test')
test 是Book表中的方法
#SerializerMethodField()使用
1.配套方法，方法名叫get_字段名，返回值就是要显示的东西
authors=serializers.SerializerMethodField()
def get_authors(self,instance):
#book对象
authors = instance.authors.all()
for author in authors:
ll=[]
for author in authors: ll.append({'name':author.name,'age':author.age})
return ll
补充
1 如果有这个错（把rest_framework在app中注册一下）
![1594086609193]()
2补充自己封装Respons对象
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)
3 你在实际开发中碰到的问题及如何解决的
write_only_fields 不能使用了，使用extra_kwargs解决了
extra_kwargs = {
'id': {'write_only': True},
}
请求和响应
请求
# 请求对象
# 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
基于APIView写接口
#### 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()),
基于GenericAPIView写的接口
# 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()),
基于GenericAPIView写的5个视图扩展类写的接口
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()),
使用ModelViewSet编写5个接口
# 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'})),
源码分析ViewSetMixin
# 重写了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视图类
# 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'})),
路由
# 在urls.py中配置
path('books4/',views.Book4View.as_view())
re_path('books4/(?p\d+ )')
views.Book4DetailView.as_view()
#一旦视图类，继承了ViewSetMixin 路由
path('books5/',views.Book5View.as_view(action={'get':'list','post':'creat'})),# 当路径匹配，又是get请求，会执行Book5View 的list办法
re_path('books5/(?p\d+)'),
view.Book5View.as_view(action={'get':'retrieve','put':'update','delete':'destroy'})
# 继承视图类，ModelViewSet路由写法
-urls.py
#第一步，导入routers模块
from rest_framework import routers
# 第二步，有两个类，实例化得到对象
# routers.DefaultRouter 生成路由更多
# routers.SimleRouuter 生成少
# 第三步：注册
# router.register('前缀'，'继承自ModelViewSet视图类'，'别名')
router.register('book',views.BookViewSet)# 不需要加斜杠
#第四步
router.urls # 自动生成路由
#print(router.url)
#urlpatterns += router.urls
-views.py
from rest_framework.viewsets import ModelViewSet
from app01.model import Book
from app01.ser import BookSerializer
class BookViewSet(ModelViewSet):
queryset =Book.objects
serializer_class = BookSerializer
action的使用
# action干什么用，为了给继承自ModelViewSet视图类定义函数也添加路由
#使用
calss BookViewSet(ModelViewSet):
queryset = Book.object.all()
serializer_class = BookSerializer
# model 第一个参数，传一个列表，列表中放请求方式
# ^books/get_1/$ [name='book-get-1'] 当向这个地址发送get请求，会执行下面的函数
# detail：布尔类型 如果是True
# ^books/(?p[^/.]+)/get_1/$[name='book-get-1']
@action(methods=['GET','POST'],detail=True)
def get_1(self,request,pk):
print(pk)
book = self.get_queryset()[:2]
ser=self.get_serializer(book,many=True)
return Response(ser.data)
认证
写法
#认证实现
1.写一个类，继承BaseAuthentication，重写1authenticate,认证的逻辑写在里面，认证通过，返回两个值，一个值最终给了Request对象的user，认证失败，抛异常，APIException或者AuthenticationFailed
2.全局使用，局部
源码分析
#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 AuthenticationFaild
from app01.models import UserToken
class MyAuthontication(BaseAuthentication):
def authenticate(self,requset):
# 认证逻辑，如果认证通过，返回两个值
# 如果认证失败，抛出抛出AuthenticationFailed异常
token = request.GET.get('token')
if token:
user_token = UserToken.object.filter(token=token).first()
#认证通过
if user_token:
return user_token.user,token
else:
raise AuthenticationFaild('认证失败')
else:
raise AuthenticationFaild('请求地址中需要携带token')
#可以有多个认证，从左到右一次执行
#全局使用，在setting.py中配置
REST_FRAMEWORK={
"DEFAULT_AUTHENTICATION_CLASSES":["app01.app_auth.MyAuthentication",]
}
# 局部使用，在视图类上写
authentication_classes = [MyAuthentication]
#局部禁用
authentication_classes=[]