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<pk>\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<pk>\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<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实际用途
# 序列化多条，需要传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)
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<pk>\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<pk>\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<pk>\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<pk>\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<pk>\d+ )')
views.Book4DetailView.as_view()
#一旦视图类，继承了ViewSetMixin 路由
path('books5/',views.Book5View.as_view(action={'get':'list','post':'creat'})),# 当路径匹配，又是get请求，会执行Book5View 的list办法
re_path('books5/(?p<pk>\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<pk>[^/.]+)/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=[]
权限
源码分析
# 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)
)
使用
# 写一个类继承BasePermission 重写has_permission，如果权限通过，就返回Ture，，不通过就返回False，
from rest_framework.permission 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]
# 全局使用
在setting中配置
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分钟访问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 SeesionAuthentication,BaseAuthentication
class TestView(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 = []
tgrottle_classes = [AnonRateThrottle]
def get(self,request,*args,**kwargs)
return Response('我是未登录用户')
内置频率限制登录用户访问频次
# 未登录用户一分钟访问5次，登录用户一分钟访问10次
# 需求：未登录用户1分钟访问5次，登录用户一分钟访问10次
全局：在setting中
'DEFAULT_THROTTLE_CLASSES': (
'rest_framework.throttling.AnonRateThrottle',
'rest_framework.throttling.UserRateThrottle'
),
'DEFAULT_THROTTLE_RATES': {
'user': '10/m',
'anon': '5/m',
}
局部配置：
UserRateThrottle
class TestView6(APIView):
authentication_classes=[]
permission_classes = []
throttle_classes = [UserRateThrottle]
def get(self,request,*args,**kwargs):
return Response('我是未登录用户，TestView6')
过滤
#1 安装：pip3 install django-filter
#2 注册，在app中注册
#3 全局配，或者局部配
'DEFAULT_FILTER_BACKENDS': ('django_filters.rest_framework.DjangoFilterBackend',)
# views.py
class BookView(ListAPIView):
queryset = Book.object.all()
serializer_class = BookSerializer
filter_fields = ('name',)#配置可以按照那个字段来过滤
排序
from rest_framework.generics import ListAPIView
from rest_framework.filters import OrderingFilter
from app01.models import Book
from app01.ser import BookSerializer
class Book2View(ListAPIView):
queryset = Book.object.all()
serializer_class = BookSerializer
filter_backends = [OrderingFilter]
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
异常处理
# 自定义异常处理
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 = execption_handler(exc,context)
# 两种情况，一个是None，drf没有处理
#response对象，django处理了，但是处理的不符合咱们的要求
if not response:
if isinstance(exc,ZeroDivisionError)
return Response(data={'status':111,'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(data={'status':888,'msg':response.data.get('detail')},status=status.HTTP_400_BAD_REQUEST)
# 全局配置setting.py
'EXCEPTION_HANDLER': 'app01.app_auth.my_exception_handler',
封装对象
class APIResponse(Response):
def __init__(self,code=100,msg='成功',data=None,status=None,headers=None,**kwargs):
dic = {'code':code,'msg':msg}
if data:
dic = {'code':code,'msg':msg,'data':data}
book系列表的接口
# 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()),
]
# 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 = BookModelSerlizer(book_list,many=True)
# 查一个
# 同上,查询单个和查询多个合到了一起
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.serializer import ListSerializer
book_ser = BookModelSerializer(data=request.data,many=True)
book_ser.is_valid(raise_exception=True)
book_ser.save()
return Response(data=book_ser.data)
def create(self,validated_data):
self.child是BookModelSerializer对象
return [
self.child.create(attrs) for attrs in validated_data
]
def put(self,request,*args,**kwargs):
if kwargs.get('pk',None):
book = model.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:
#改多个
book_list = []
modify_data=[]
for item in request.data:
pk = item.pop('id')
book = model.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)
def delete(self,request,*args,**kwargs):
#单个删除批量删除
pk = kwargs.get('pk')
pks = []
if pk:
#单条删除
pks.append(pk)
# 不管删除单条还是多条，都用多条删除
else:
pks = request.data.get('pks')
# 把is_delete改为true
# ret返回影响行数
ret = model.Book.object.filter(pk__in=pks,is_delete=False).update(is_delete=True)
if ret:
return Response(data={'msg':'删除成功'})
else:
return Response(data={'msg':'没有要删除的数据'})
# ser.py
from rest_framework import serializers
from api import models
# 写一个类继承ListSerializer,重写update
class BookListSerializer(serializers.ListSerializer):
def create(self,validated_data):
return super().create(validated_data)
def update(self,instance,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 [self.child.update(对象，字典)for attrs in validated_data
self.child.update(instance[i],attrs) for i,attrs in enumerate(validated_data]
# 如果序列化的是数据库的表，尽量用ModelSerializer
class BookModelSerializer(serializer.ModelSerializer)
class Meta:
list_serializer_class = BookListSerializer
model = model.Book
firlds =('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}
}
# models.py
from django.db import models
from django.contrib.auth.models import AbstractUser
class BaseModel(models.Model):
is_delete = mdoels.BooleanField(default=False)
# auto_now_add=True 只要记录创建，不需要手动插入时间，自动把当前时间插入
create_time = models.DateTimeField(auto_now_add=True)
# auto_now=True,只要更新，就会把当前时间插入
last_update_time = mdoels.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 = mdoels.CharField(max_length=32,verbose_name='书名',help_text='写书名')
price = models.DecimalField(max_digiits=5,decimal_places=2)
# 一对多关系一旦确立，关联字段写在多的一方
# to_field 默认不写，关联到Publish主键
# db_constraint = False 逻辑上的关联，实质上没有外键联系，增删不会受到外键影响，但是orm查询不受影响,db_constraint=False,这个就是保留跨表查询的便利(双下划线跨表查询```),但是不用约束字段了,一般公司都用false,这样就省的报错,因为没有了约束(Field字段对象,既约束,又建立表与表之间的关系)
publish = models.Foreignkey(to='publish',on_delete=models.DO_NOTHING,db_constraint=False)
# 多对多，跟作者，关联字段，查询次数多的一方
# 第三张表只有关联字段，用自动；第三张表有扩展字段，需要手写，，不能写on_delete
author=models。ManyToManyField(to='Author',db_constraint=False)
class Meta:
verbose_name_plural='书表'
def __str__(self):
return self.name
@property
def publish_name(self):
return self.publisih.name
def author_list(self):
author_list = self.authors.all()
ll = []
for author in author_lsit:
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 = model.CharField(max_length=32)
def __str__(self):
return self.name
class Author(BaseModel):
name = models.ChaeField(max_length=32)
sex=models.IntegerField(choices=((1,'男'),(2,'女')))
# 一对一关系卸载查询率高的一方
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
分页器
# views.py
#查所有才需要分页
from rest_framework.generics import ListAPIView
#内置分页
from rest_framework.pagination import PageNumberPagination,LimitOffsetPagination,CursorPaination
class MyPageNumberPageination(PageNumberPagination):
page_size = 3 # 每页条数
page_query_param = 'aaa' #查询第几页key
page_size_query_param = 'size' # 每一页条数
max_page_size = 5
class MyLimitOffsetPagination(LimitOffsetPagination):
default_limit = 3 # 每页条数
limit_query_param = 'limit' # 往后取几条
offset_query_param = 'offset' #标杆
max_limit = 5 #每页最大几条
class MyCursorPagination(CursorPagination):
cursor_query_param = 'cursor'# 每一页查询key
page_size = 2 #每页显示的条数
ordering = 'id' 或 '-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 分页
from utils.throtting import MyThrottle
class BookView(APIView):
def get(self,request,*args,**kwargs):
book_list = models.Book.objecta.all()
# 实例化得到一个分页器的对象
page_cursor = MyPageNumberPagination()
book_list = page_cursor.paginate_querset(book_list,request,view=self)
next_url = page_cursor.ge_next_link()
pr_url = page_cursor.get_previous_link()
book_ser = BookModelSerializer(book_list,many=True)
return Response(data=book_ser.data)
#settings.py
REST_FRAMEWORK={
'PAGE_SIZE': 2,
}
根据ip进行频率限制
# 写一个类继承继承SimpleRateThrottle,只要重写get_cache_key
from rest_framework.throttling import ScopedRateThrottle,SimpleRateThrottle
# 继承SimpleRateThrottle
class MyThrottle(SimpleRateThrottle):
scope='lufei'
def get_cache_key(self,request,view)
retrn request.META.get('REMOTE_ADDR')
# 局部使用，全局使用
REST_FRAMEWORK={
'DEFAULT_THROTTLE_CLASSES': (
'utils.throttling.MyThrottle',
),
'DEFAULT_THROTTLE_RATES': {
'luffy': '3/m' # key要跟类中的scop对应
},
}
自定制频率
# 自定制频率，需要两个方法
#判断是否限次，没有限次可以请求True，限次不可以请求False
#限次后调用，显示还需要等待多长时间才能访问，返回需要等待时间seconds
import time
class IPThrottle():
#定义成类属性,所有对象用的都是这个
VISIT_DIC = {}
def __init__(self):
self.history_list=[]
def allow_request(self, request, view):
1.取出访问者的ip
2.判断在不在访问字典里，不在就添加进去，并返回True，表示第一次访问，在字典里，continue
3.循环当前的ip表，当前时间减去列表最后一格时间大于60s，把这种数据pop掉，列表里只有60s以内的
4.当列表小于3说明一分钟不足三次，把当前时间插入到列表第一个位置，返回True
5.当大于等于3，说明一分钟访问超过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_lsit.insert(0,ctime)
return True
else:
return False
def wait(self):
# 当前时间，减去列表中最后一个时间
ctime = time.time()
return 60-(ctime-self.history_list[-1])
Simpleratethrottle源码分析
# 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:
修改图书的阅读量
"""
JWT认证
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),
自定制auth认证类
from rest_framework_jwt.authentication import BaseAuthentication,BaseJSONWebTokenAuthentication
from rest_framework.exceptions import AuthenticationFailed
from rest_framework_jwt.authentication import jwt_decode_handler
from rest_framework_jwt.authentication import get_authorization_header,jwt_get_username_from_payload
from rest_framework import exceptions
class MyToken(BaseJSONWebTokenAuthentication):
def authenticate(self,request):
jwt_value=str(request.META.get('HTTP_AUTHORIZATION'))
try:
payload = jwt_decode_handler(jwt_value)
except Exception:
raise exception.AuthenticationFaild('认证失败')
user = slef.authenticate_credentials(payload)
return user,None
jwt
控制用户登录后才能访问，不登录也能访问
#登录才能访问
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('这，不登录也能访问')
控制登录接口返回的数据格式
# 控制登录接口返回的数据格式
第一种方案，字节写登录接口
第二种，用内置，控制登录接口返回的数据格式
-jwt的配置信息中有这个属性
'JWT_RESPONSE_PAYLOAD_HANDLER':
'rest_framework_jwt.utils.jwt_response_payload_handler',
-重写jwt_response_payload_handler，配置成咱们自己的
自定义基于jwt的权限类
#自定义基于jwt权限类
from rest_framework.authentication import BaseAuthentication # 基于它
from rest_framework_jwt.authentication import BaseJSONWebTokenAuthentication # 基于它
from rest_framework.exceptions import AuthenticationFailed
# from rest_framework_jwt.authentication import jwt_decode_handler
from rest_framework_jwt.utils import jwt_decode_handler # 跟上面是一个
import jwt
from api import models
class MyJwtAuthentication(BaseAuthentication):
def authenticate(self,request):
jwt_value = request.META.get('HTTP_AUTHORIZATION')
class MyJwtAuthentication(BaseAuthentication):
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))
# 因为payload就是用户信息的字典
print(payload)
# return payload, jwt_value
# 需要得到user对象，
# 第一种，去数据库查
# 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('您没有携带认证信息')
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))
user=self.authenticate_credentials(payload)
return user,jwt_value
# 没有值，直接抛异常
raise AuthenticationFailed('您没有携带认证信息')
手动签发token（多方式登录）
# 使用用户名手机号邮箱都可以登录
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_valid
login_ser.is_valid(raise_exception=True)
token=login_ser.context.get('token')
4.return
return Response({'status':100,'msg':'登陆成功','token'：token，})
from rest_framework import serializers
from api import models
from rest_framework.execptions import ValidationError
from rest_framework_jwt.utils import jwt_encode_handler,jwt_payload_handler
class LoginModelSerializer(serializer.ModelSerializer):
username = serializer.CharField()
# 重新覆盖username字段，数据中它是unique,post,认为你是保存数据，自己校验过
class META:
mdoel = models.User
fields=['username','password']
def validate(self,attrs):
# 在这里写逻辑
username = attrs.get('username')
password = attrs.get('password')
if re.match('^1[3-9][0-9]{9}$',username): #手机号
user = models.User.object.filter(mobile=username).first()
elif re.match('^.+@.+$',username): #邮箱
user = mobile.User.object.filter(email=username).first()
else:
user=models.User.object.filter(username=username).first()
if user:
if user.check_password(password): #校验密码
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('用户不存在')
1.5 jwt的配置参数
# 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的权限系统
# 后台的权限控制（公司内部系统，crm，erp，协同平台）
user表
permssion表
group表
user_groups表是user和group的中间表
group_permissions表是group和permssion中间表
user_user_permissions表是user和permission中间表
# 前台（主站），需要用三大认证
# 演示：
django缓存
# 前端混合开发缓存的使用
-缓存的位置，通过配置文件来操作（以文件为例）
-缓存的粒度：
-全站缓存
中间件
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')
-应用场景：
-第一次查询所有图书，你通过多表联查序列化之后的数据，直接缓存起来
-后续，直接先去缓存查，如果有直接返回，没有，再去连表查，返回之前再缓存
