drf入门规范
1、前后端开发模式：
-混合模式：也就是BBS项目
-前后端分离模式：只负责写接口，不用管前端
2、API接口：
-长得像返回数据的url链接
-请求方式：get、post、put等等
-请求参数：地址、请求体
-返回数据
-写接口为了给谁用？
前端(web、app)，或者提供给第三方调用
3、接口测试工具------->postman
-发送http请求工具
-get请求可以在请求体中携带数据
-get请求和post请求有什么区别?
-请求编码格式：
-urlencoded：key=value&key=value------->从request.POST中取
-form-data：数据和文件混在一起------->文件从request.FILES中取，数据从request.POST中取
-json：{"name":"XXX"}------->>数据从request.body中取
-collections创建，保存导出
4、接口规范，restful规范：
-数据安全的保障
-接口特征的变现
-多数据版本共存
-数据既是资源，均使用名词（可复数）
-资源操作由请求的方式来决定（method）
-过滤，通过在url上传参的形式传递搜索条件
-响应状态码（两层）
-错误处理，应返回错误信息，error当key
-返回结果，针对不同操作，服务器向用户返回的结果应该符合以下规范
-需要url请求的资源需要访问资源的请求链接
5、序列化和反序列化：
-序列化：将我的数据类型转换成json格式字符串可供其他语言使用
-反序列化：将其他语言提供给我们的数据类型，转换成我们自己可以识别的数据类型
6、drf：
Django框架上的一款APP，方便我们快速编写符合restful规范的接口
7、CBV源码分析：
.....
8、APIView比View多出了哪些东西
-在dispatch中执行了视图类中与请求方式同名的方法
-去掉了csrf验证
-包装了全新的request
-执行了三大认证
-处理了全局异常
-可以直接在视图类中的方法中self.request
get请求和post请求的区别
GET请求和POST请求是HTTP协议中常用的两种请求方法，它们在以下几个方面有所区别：
1. 参数传递方式：
- GET请求：参数通过URL的查询字符串（query string）传递，即参数会附加在URL的末尾，使用`?`进行分隔，多个参数之间使用`&`符号连接。例如：`http://example.com/path?param1=value1¶m2=value2`
- POST请求：参数通过请求体（request body）传递，参数不会附加在URL中，而是在请求体中进行传递。参数的格式可以是表单形式（`application/x-www-form-urlencoded`）或者是JSON等其他格式。
2. 参数长度限制：
- GET请求：由于参数附加在URL中，URL的长度是有限制的，不同的浏览器和服务器对URL长度的限制不一样，一般在2KB到8KB之间。超过限制的参数可能会被截断或丢失。
- POST请求：请求体的长度一般没有明确的限制，但是具体的限制取决于服务器的配置和资源。
3. 安全性：
- GET请求：参数附加在URL中，会被保存在浏览器的历史记录、服务器的日志文件等地方，容易被他人获取。因此，不适合传递敏感信息（如密码）。
- POST请求：参数在请求体中传递，不会被保存在URL中，相对于GET请求更安全，适合传递敏感信息。
4. 幂等性：
- GET请求：一般情况下是幂等的，即多次重复请求不会产生副作用。
- POST请求：一般情况下是非幂等的，即多次重复请求可能会产生副作用，如创建重复的资源。
5. 缓存：
- GET请求：可以被浏览器缓存，可以通过在请求头中设置`Cache-Control`等字段来控制缓存策略。
- POST请求：一般不会被浏览器缓存。
根据具体的需求和场景，选择合适的请求方法是很重要的。一般来说，GET请求适合获取资源，而POST请求适合提交数据或执行操作。
http和https协议的区别
HTTP（Hypertext Transfer Protocol）和HTTPS（Hypertext Transfer Protocol Secure）是两种常见的网络传输协议，它们在以下几个方面有所区别：
1. 安全性：
- HTTP：是明文传输协议，数据传输过程中不进行加密，容易被窃听和篡改。因此，HTTP不适合传输敏感信息。
- HTTPS：是通过使用SSL（Secure Sockets Layer）或TLS（Transport Layer Security）协议对HTTP进行加密的协议。通过使用公钥加密和私钥解密的方式，HTTPS可以保证数据在传输过程中的安全性，防止数据被窃听和篡改。
2. 默认端口：
- HTTP：默认使用端口80进行通信。
- HTTPS：默认使用端口443进行通信。
3. 证书：
- HTTP：不需要证书。
- HTTPS：需要使用SSL证书，证书由可信的第三方机构（CA）签发，用于验证服务器的身份。证书包含了服务器的公钥，用于加密数据传输。
4. 性能：
- HTTP：由于数据传输过程中没有加密和解密的过程，相对于HTTPS来说，性能更高。
- HTTPS：由于数据传输过程中需要进行加密和解密的过程，相对于HTTP来说，性能略低。
5. SEO（Search Engine Optimization）：
- HTTP：搜索引擎更容易识别和索引HTTP网页。
- HTTPS：搜索引擎更倾向于将HTTPS网页排名更高，因为HTTPS可以提供更安全的用户体验。
需要注意的是，为了提高网站的安全性和保护用户的隐私，现在越来越多的网站采用了HTTPS协议。在使用HTTPS时，网站需要获得有效的SSL证书，并进行相应的配置。
序列化组件
1、序列化组件的介绍：
-可以对数据进行序列化------->queryset对象
-可以对数据进行反序列化------->前端出入的json格式的数据------->保存到数据库中
-可以对数据进行反序列化检验------->字段自己的校验，局部钩子、全局钩子
2、序列化组件的快速使用:
-先写一个类继承继承Serializer
-在类中写入字段
-在视图类中：实例化得到序列化类的对象
-序列化：序列化类的对象.data retrun Response(ser.data)
3、常用字段类
-跟models里面的没有区别，只是多出来两个：DictField、ListField，这两个参数一个接收字典类型、一个接受列表类型，这两个字段都可以进行序列化和反序列化
4、字段参数：
-read_only = True 只做序列化
-write_only = False 只做反序列化
5、继承Serializer做反序列化新增或修改组需要重写create方法和updata方法
-新增
ser=BookSerializer(data=request.data)
ser.is_valid(raise_exception=True)--->只要校验不通过，直接抛异常
ser.save() # 继承Serializer，需要在序列化类中重写create方法，完成新增
序列化类中重写create方法
def create(self, validated_data):
# validated_data 前端传入，校验过后的数据
# 新增一个对象
return 新增的对象 # 后续再视图类中只要调用ser.data,这里必须返回
-修改
ser=BookSerializer(instance=要修改的对象,data=request.data)
ser.is_valid(raise_exception=True)--->只要校验不通过，直接抛异常
ser.save() # 继承Serializer，需要在序列化类中重写update方法，完成修改
序列化类中重写update
def update(self, instance, validated_data):
# instance 要修改的对象，哪里来的？BookSerializer(instance=要修改的对象的id,data=request.data)
# validated_data：校验过后数据
res=Book.objects.filter(pk=instance).update(**validated_data)
return res # 返回的res最后干啥了？只要在 视图类中 调用ser.data,他会根据这个返回值做序列化
6、反序列化校验：
字段自己校验----->局部钩子----->全局钩子
7、返回定制格式：
-1、source：
-1、改写字段名
-2、跨表查询
-3、拿到表模型中方法
-2、SerializerMethodField：在序列化类中写
-publish = Serializers.SerializerMethodField(read_only = True)
配合一个get_publish(self,obj)方法就可以定制该字段的返回格式
-3、在表模型中写方法：
def publishdict(self)：
return {"name":publish.name}
在序列化类中：publishdict = Serializers.DictField()
-只能做序列化用了，反序列化得单独用----->需要使用read_only和write_only控制
8、ModelSerializer使用：
class Auth(Serializers.ModelSerializer):
或者可以在此处重写字段
class Meta:
model = 表名
fields = "__all__" or ["字段名","字段名"......]
extra_kwargs={} # 传入字段参数
大部分情况下不需要写create和update了
局部，全局钩子跟之前一模一样
视图组件
1、两个视图基类：
APIView：
-类属性:
renderer_classes = api_settings.DEFAULT_RENDERER_CLASSES
parser_classes = api_settings.DEFAULT_PARSER_CLASSES
authentication_classes = api_settings.DEFAULT_AUTHENTICATION_CLASSES
throttle_classes = api_settings.DEFAULT_THROTTLE_CLASSES
permission_classes = api_settings.DEFAULT_PERMISSION_CLASSES
GenericAPIView:
-类属性：
-queryset = None
-serializer_class = None
-lookup_field = 'pk'
-filter_backends = api_settings.DEFAULT_FILTER_BACKENDS
-pagination_class = api_settings.DEFAULT_PAGINATION_CLASS
-类方法：
-get_queryset：获取所有要序列化的数据
-get_obj：获取单个对象
-get_serializer：------>调用了get_serializer_class------>返回了序列化类的对象以及要传入的参数----->instance，data，many
-filter_queryset----->给ListModelMixin用的，把配置的filter_backends 依次执行完成过滤
2、5个视图扩展类需要搭配GenericAPIView使用
-ListModelMixin,
-CreateModelMixin,
-UpdateModelMixin,
-DestroyModelMixin,
-RetrieveModelMixi
-如果一个视图类要写四个接口，必须要借助于ViewSetMixin餐可以完成
3、九个视图子类：
九个视图子类是继承了GenericAPIView以及5个视图扩展类搭配出来的
...........略
4、视图集：
ViewSetMixin：改变了路由的写法
诞生出来的子类：
-ReadOnlyModelViewSet：RetrieveModelMixin + ListModelMixin + GenericViewSet
-ModelViewSet：GenericViewSet+5个视图扩展类
-ViewSet：ViewSetMixin + APIView
-GenericViewSet：ViewSetMixin + GenericAPIView
请求与响应
1、请求：
-请求源码：request对象
-request.data：前端传入的数据
-request.query_params：url中携带的参数
-request._request：未封装前的request
-为什么我封装了request以后还可以使用以前的方法？
-因为在新的request中有一个__getattr__方法，会将为封装前的方法反射到我封装后的request方法上面
-请求能解析编码格式：parser_classes
-局部使用
-全局使用
2、响应
-响应Response 源码
-data：响应体的内容，序列化后的数据给了他
-headers:响应头 django原生响应头 响应对象['xx']=xxx
-status:响应状态码
-响应编码格式-->浏览器，postman，看到的样子
-局部和全局配置
# 写了个视图类 获取所有接口
class BookView(ViewSetMixin,GenericAPIView,ListModelMixin):
queryset = None
serializer_class = None
def list(self,request,*args,**kwargs):
res=super().list(request,*args,**kwargs)
# 返回字典格式
res.data # {code:100,msg:成功，data：[{},{}]}
return Response({code:100,msg:成功,data:res.data})
路由组件
1 只要继承ViewSetMixin及其子类，路由写法就变了
-方式一：映射方式
视图类.as_view({'get':'lqz'})
-方式二：自动生成
-SimpleRouter DefaultRouter：区别是DefaultRouter会带根目录
2 action装饰器：methods：请求方式 detail：为True URL中带数字 ，为False 则不带
认证权限频率
1、认证类的使用：
-1、写一个类，继承BaseAuthentication
-2、重写 def authenticate(self, request):方法
-3、取出用户传入的token----->通过token判断登录的用户
-4、认证成功取出用户，认证失败抛出异常
-5、return 查到的对象、token，后续通过request.user取出返回的第一个值，request.auth取出第二个值
2、权限类：
-1、写一个类，继承BasePermission
-2、重写 def has_permission(self, request, view):方法
-3、判断用户的权限
acl：权限，取出当前用户所有权限，判断当次请求是否在权限中
rbac：根据当前用户取出所有角色，通过角色取出所有权限，去个重，判断是否在权限中
-4、有权限返回True，没有权限返回False
-5、在视图类中配置或者全局配置
3、频率类：
-1、写一个类，继承SimpleRateThrottle
-2、重写 def get_cache_key(self, request, view):方法
-3、类属性配置 scope = "字符串"
-4、配置文件中配置
'DEFAULT_THROTTLE_RATES':
{
'字符串': '3/m',
}
-5、视图类中配置，全局配置
为什么我们写了 权限类，配置行，它就会执行权限控制？
-APIView 的dispatch中执行了3大认证---》
def dispatch(self, request, *args, **kwargs):
self.initial(request, *args, **kwargs) # 三大认证
initial源码：
def initial(self, request, *args, **kwargs):
self.perform_authentication(request) # 认证类
self.check_permissions(request) # 权限类
self.check_throttles(request) # 频率类
权限类源码分析
入口：self.check_permissions(request)
def check_permissions(self, request):
# for循环我这个对象列表
for permission in self.get_permissions():
# 如果has_permission(request, self)返回的是False，注意括号内的这个self是视图类的对象
if not permission.has_permission(request, self):
# 如果有任何一个权限对象返回False，则调用permission_denied方法抛出异常。同时，可以通过getattr方法获取权限对象的message和code属性，并作为参数传递给permission_denied方法
self.permission_denied(
request,
message=getattr(permission, 'message', None),
code=getattr(permission, 'code', None)
)
def get_permissions(self):
# 使用列表生成式从permission_classes取出一个个自己写的权限类，实例化得到的对象列表返回出去
return [permission() for permission in self.permission_classes]
认证类源码分析
入口：self.perform_authentication(request)
def perform_authentication(self, request):
# 点进来发现只有一个request.user,所以我们要去Request里面去找User的方法看看是不是方法为装成了属性
request.user
Request类中：
@property
def user(self):
# 如果request这个对象中没有_user这个属性就会走下一步
if not hasattr(self, '_user'):
# 使用with语句和wrap_attributeerrors()上下文管理器，捕获AttributeError异常。
with wrap_attributeerrors():
self._authenticate()
# 如果有这个属性直接返回出去
return self._user
_authenticate方法：
def _authenticate(self):
# for循环我视图类中的认证类的对象列表
for authenticator in self.authenticators:
try:
# 调用我自己写的认证类中的authenticate方法，这个地方的self是request的对象
user_auth_tuple = authenticator.authenticate(self)
except exceptions.APIException:
self._not_authenticated()
raise
# 如果user_auth_tuple不为None
if user_auth_tuple is not None:
# _authenticator拿到的就是我的认证类
self._authenticator = authenticator
# 通过解压赋值将用户给user，token给auth
self.user, self.auth = user_auth_tuple
return
self._not_authenticated()
-认证类可以配置多个，但是如果有一个返回了，后续的就不走了
self.authenticators 是request对象的属性，是在Request实例化的时候传入的，它什么时候实例化的，包装新的Reqeust时传入的--->APIView的dispatch-->request = self.initialize_request(request, *args, **kwargs)，initialize_request下的------>authenticators=self.get_authenticators()下的get_authenticators------>
def get_authenticators(self):
# 通过里边生成式遍历我视图类中的列表，然后实例化得到一个对象
return [auth() for auth in self.authentication_classes]
频率源码分析
源码入口：self.check_throttles(request)
def check_throttles(self, request): 方法
def check_throttles(self, request):
throttle_durations = []
# 遍历我频率类对象的列表
for throttle in self.get_throttles():
# 执行频率类中的allow_request，并传入两个参数一个是一个request一个是我试图类的对象，返回True或者False，如果返回True
if not throttle.allow_request(request, self):
# 显示还剩多长时间才可以进行访问
throttle_durations.append(throttle.wait())
# 调用了这个方法
def get_throttles(self):
# 使用列表生成式循环我视图类中的频率类列表，并调用放到一个列表中
return [throttle() for throttle in self.throttle_classes]
频率类要写
1 写一个类，继承，BaseThrottle
2 在类中重写：allow_request方法，传入 3个参数
3 在allow_request写限制逻辑，如果还能访问--》返回True
4 如果超了次数，就不能访问，返回False
5 局部配置在视图类上
6 全局配置在配置文件中
我们自己写频率类的时候，继承了SimpleRateThrottle只重写了 def get_cache_key(self, request, view):方法，猜测可能是SimpleRateThrottle帮我们重写了该方法
SimpleRateThrottle 源码分析：
def allow_request(self, request, view):
# 咱们没写，以后咱们可以在频率类中直接写
# rate='3/m' 以后不用写scope了，就会按一分钟访问3次现在
if self.rate is None:
return True
# 调用我的get_cache_key方法返回的值，咱们返回了访问者ip
self.key = self.get_cache_key(request, view)
# 判断是否为None，为None返回True
if self.key is None:
return True
# 根据当前访问者ip，取出 这个人的访问时间列表 [访问时间1，访问2，访问3，访问4]
self.history = self.cache.get(self.key, [])
# 得到当前时间
self.now = self.timer()
# 去除掉访问时间大于60秒的
while self.history and self.history[-1] <= self.now - self.duration:
self.history.pop()
# 判断这个列表长度是否大于3，如果大于等于3返回False
if len(self.history) >= self.num_requests:
return self.throttle_failure()
# 否则调用throttle_success方法
return self.throttle_success()
# 在SimpleRateThrottle实例化的时候会触发这个方法
def __init__(self):
# 判断有没有rate这个属性
if not getattr(self, 'rate', None):
# 如果没有调用get_rate()方法来获取rate的值并赋给self.rate
# self.rate拿到的是'3/m'
self.rate = self.get_rate()
# 如果有值将会调用parse_rate方法，将self.tate传入，将返回的结果分别给self.num_requests, self.duration
self.num_requests, self.duration = self.parse_rate(self.rate)
# def get_rate(self):方法
def get_rate(self):
# 判断有没有scope这个属性
if not getattr(self, 'scope', None):
# 如果没有直接抛异常
msg = ("You must set either `.scope` or `.rate` for '%s' throttle" %
self.__class__.__name__)
raise ImproperlyConfigured(msg)
try:
"""
频率类中：
scope = xxx
'DEFAULT_THROTTLE_RATES': {
'xxx': 3/m,
'anon': None,
}
"""
# 从配置文件中拿到scope这个属性对应的值，返回出去
return self.THROTTLE_RATES[self.scope]
except KeyError:
msg = "No default throttle rate set for '%s' scope" % self.scope
raise ImproperlyConfigured(msg)
# def parse_rate(self, rate)
def parse_rate(self, rate):# rate是3/m
# 判断rate是否为空，如果为空返回None
if rate is None:
return (None, None)
# 按照/进行切分，把3给num，m给period
num, period = rate.split('/')
# 将num转成一个整型
num_requests = int(num)
# 判断我period索引为0位置的字符在不在我这个字典中
duration = {'s': 1, 'm': 60, 'h': 3600, 'd': 86400}[period[0]]
# 返回我的数字3以及m对应的60
return (num_requests, duration)
# def throttle_success(self):方法
def throttle_success(self):
# 在self.history列表第0个位置插入一条当前时间
self.history.insert(0, self.now)
# 使用self.cache.set方法将更新后的历史记录列表存储到缓存中，缓存键为self.key，过期时间为self.duration，表示该缓存记录在一定时间后过期。
self.cache.set(self.key, self.history, self.duration)
return True
继承BaseThrottle自定义的频率类
class MyThrottle(BaseThrottle):
VISIT_RECORD = {}
def allow_request(self, request, view):
# 写限制逻辑
# （1）取出访问者ip
user_ip = request.META.get('REMOTE_ADDR')
# （2）判断当前ip不在访问字典里，添加进去，并且直接返回True,表示第一次访问，在字典里，继续往下走
if user_ip not in self.VISIT_RECORD:
self.VISIT_RECORD[user_ip] = [datetime.datetime.now()]
print("++++++", self.VISIT_RECORD)
return True
# （3）循环判断当前ip的列表，有值，并且当前时间减去列表的最后一个时间大于60s，把这种数据pop掉，这样列表中只有60s以内的访问时间，
visit_times = self.VISIT_RECORD[user_ip]
# visit_times = [visit_time for visit_time in visit_times if (datetime.datetime.now() - visit_time).seconds
# <= 60]
filtered_visit_times = []
for visit_time in visit_times:
if (datetime.datetime.now() - visit_time).seconds <= 60:
filtered_visit_times.append(visit_time)
# （4）判断，当列表小于3，说明一分钟以内访问不足三次，把当前时间插入到列表第一个位置，返回True，顺利通过 （5）当大于等于3，说明一分钟内访问超过三次，返回False验证失败
if len(filtered_visit_times) < 3:
# 将当前时间插入到列表的第一个位置
filtered_visit_times.insert(0, datetime.datetime.now())
print("------", filtered_visit_times)
self.VISIT_RECORD[user_ip] = filtered_visit_times
return True
return False
# 频率类写好，配置在视图类上，就会走它
继承SimpleRateThrottle自定义频率类
class IPRateThrottle(SimpleRateThrottle):
scope = "Wayyy"
def get_cache_key(self, request, view):
token = request.GET.get("token")
user_id = request.user.pk
return f"{self.scope}:{token}:{user_id}"
过滤排序分页全局异常
过滤
针对于查询所有接口----->继承：GenericAPIView+ListModelMixin--->只需要在视图类中写一个类属性----->filter_backends = [过滤类，过滤类2]
1 内置的：SearchFilter 类属性：search_fields=[可以按字段过滤]
127.0.0.1:8080/books/?search=红
2 第三方
-django-filter
-精准匹配
127.0.0.1:8080/books/?name=红楼梦
-能更强大
3 自定义的
写一个类，继承：BaseFilterBackend
重写 filter_queryset
在filter_queryset中完成过滤，会把qs传入，返回过滤后的qs即可
源码分析:
get请求来了------>会触发我list方法的执行，会调用GenericAPIView中的filter_queryset方法，在这个方法中会将filter_backends强转成列表形式（所以我在视图类中也可以直接让filter_backends=过滤类），然后使用for循环遍历这个列表，然后再实例化我这个过滤类，执行里边的filter_queryset方法进行筛选数据，将筛选后的数据返回出去
继承APIView写过滤:
request 取出过滤条件
book_list=Book.objects.all().filter(过滤)
排序
针对于查询所有接口---》继承：GenericAPIView+ListModelMixin---》只需要在视图类中写一个类属性---》filter_backends = [排序类]
内置排序类即可：OrderingFilter---》配置类属性ordering_fields
自定义排序类，完成自己的规则
分页
针对于查询所有接口-->才有分页
三种分页方式，必须继承分页类，重写几个类属性实现--->配置在视图类上-->继承：GenericAPIView+ListModelMixin
PageNumberPagination：用的最多，之前常见的分页方式，查询第几页，每页有多少条的分页方式 ：page=10&size=3
LimitOffsetPagination：从第几条开始，取几条 offset=10&limit=3 从第10条开始，取3条
CursorPagination：只能上一页和下一页，需要排好序再分页
继承APIView 写分页:
class Pager(APIView):
def get(self,request,*args,**kwargs):
# 获取所有数据
ret=models.Book.objects.all()
# 创建分页对象
page=PageNumberPagination()
# 在数据库中获取分页的数据
page_list=page.paginate_queryset(ret,request,view=self)
# 对分页进行序列化
ser=BookSerializer1(instance=page_list,many=True)
# return Response(ser.data)
# 这个也是返回Response对象，但是比基本的多了上一页，下一页，和总数据条数（了解即可）
return page.get_paginated_response(ser.data)
return Response(ser.data) # 只会有数据，不会有上一页和下一页，总条数
分页源码分析：
get请求过来----->执行list方法，先进行过滤，过滤完以后，开始分页，会执行GenericAPIView中的paginate_queryset方法，这个方法又会触发paginator的方法执行，在paginator的方法中会调用pagination_class属性，返回我分页类的一个对象，在paginate_queryset会拿到这个对象，判断是否为None，如果为None返回None，否则就
会调用分页类中的paginate_queryset方法，来完成分页
全局异常处理
前后端分离了，后期，后端出了异常，我们不想让前端看到，我们需要捕获全局异常，统一返回格式
之所以能捕捉到异常是因为在APIView中的dispatch中try了一下，如果出现异常了就会执行APIView中的handle_exception方法，这个方法中需要传入一个我的异常信息，这个方法会调用get_exception_handler方法，get_exception_handler方法就是在配置文件中拿到我配置的捕捉异常的那个函数，如果我没有配置就会用drf中的那个捕捉异常的函数
自己处理全局异常的步骤：
1 写一个函数，在内部处理
from rest_framework.views import exception_handler
def common_exception_handler(exc,context):
res=exception_handler(exc,context)
if res: #这次异常是drf的，并且它处理了
# 我们要统一返回格式
return Response({'code':888,'msg':"系统异常（drf异常），请联系系统管理员：%s"%res.data.get('detail',None)})
else:
return Response({'code': 999, 'msg': "系统异常（非drf异常），请联系系统管理员：%s" % str(exc)})
2 配置在配置文件上
接口文档
# 接口写完，必须编写接口文档，给别人用
# 接口文档规范：要有什么东西
1 描述
2 地址
3 请求方式
4 请求编码格式
5 请求参数，详解
6 返回示例 json
7 返回示例中字段详解
# 编写的位置：
1 直接写在文件中共享(word,md)
2 平台上写
- 公司搭建的平台（自己研发，第三方开源）
- 使用第三方接口文档平台
3 自动生成
-coreaip
JWT认证
# JWT是什么
json web tokne缩写，一种前后端认证的方法，区别与session的方案，不需要在后端存储数据，也能实现会话保持
# jwt原理
-三段式：
-签发阶段
-登录：
用户名+密码
手机号+验证码
本机号码一键登录--》向后端就只传了手机号--》根据手机号签发token
-认证阶段
-drf中的认证类
-校验token是否合法
# 别人截获到token后，模拟发送请求
-1 设置过期时间---》10m
-2 需要登录后才能访问的接口，不仅要带token还是带个加密串 sign
-3 双token认证
-返回两个token：一个token：7天过期，一个token：10分钟过期
-以后用就只带10分钟过期的token
-过了10分钟了，10分钟token失效了
-携带着7的token到后端，生成一个10分钟的返回
-原来的token串使用md5+盐生成一个串--》签名
# django中使用jwt--》快速签发
# 快速签发定制返回格式
# 认证：jwt提供的认证 一个认证类，一个权限类
# 自定义用户表
签发
payload = jwt_payload_handler(user)
token = jwt_encode_handler(payload)
认证：认证类
token = request.META.get('HTTP_TOKEN')
payload = jwt_decode_handler(token)
user = User.objects.get(pk=payload.get('user_id'))
# 多方式登录（auth的user表）
-把校验和签发token逻辑写在序列化类的 全局钩子中了
-在全局钩子中，只要校验不通过，就抛异常
权限控制
# acl:访问控制列表
用户跟权限多对多
# 基于角色的访问控制 rbac
用户跟角色关系，角色和权限管理
-用户表
-角色表
-权限表
-用户和角色多对多中间表
-角色和权限多对多中间表
-用户和权限多对多
# abac：
基于属性+角色的访问控制
基于属性+访问控制列表
张三：【看视频，发视频】
张三：晚上12点凌晨7点 不能发视频
作业
# 1 整理回顾的drf内容
# 2 读 权限和认证源码
# 3 读 频率源码
# 4 自己写个频率类，实现 一分钟访问3次，根据ip地址限制
from rest_framework.throttling import BaseThrottle
class MyThrottle(BaseThrottle):
VISIT_RECORD = {'192.168.1.1':[当前时间，当前时间，访问时间列表]}
def allow_request(self, request, view):
# 写限制逻辑
# （1）取出访问者ip
# （2）判断当前ip不在访问字典里，添加进去，并且直接返回True,表示第一次访问，在字典里，继续往下走
# （3）循环判断当前ip的列表，有值，并且当前时间减去列表的最后一个时间大于60s，把这种数据pop掉，这样列表中只有60s以内的访问时间，
# （4）判断，当列表小于3，说明一分钟以内访问不足三次，把当前时间插入到列表第一个位置，返回True，顺利通过
# （5）当大于等于3，说明一分钟内访问超过三次，返回False验证失败
return False
# 频率类写好，配置在视图类上，就会走它
写个频率类，实现 一分钟访问3次，根据ip地址限制
class MyThrottle(BaseThrottle):
VISIT_RECORD = {}
def allow_request(self, request, view):
# 获取到当前访问对象的IP
user_ip = request.META.get('REMOTE_ADDR')
# 如果当前IP不在这个字典中
if user_ip not in self.VISIT_RECORD:
# 以user_ip为key值，当前时间为value值保存到字典中
self.VISIT_RECORD[user_ip] = [datetime.datetime.now()]
# 返回True
return True
# 取出当前IP的列表赋给visit_times
visit_times = self.VISIT_RECORD[user_ip]
# 定义一个空的列表
filtered_visit_times = []
# 循环我IP的那个列表赋给visit_time
for visit_time in visit_times:
# 判断当前时间减去我遍历出来的时间是否小于60秒
if (datetime.datetime.now() - visit_time).seconds <= 60:
# 如果小于60秒将这个时间追加到filtered_visit_times列表中
filtered_visit_times.append(visit_time)
# 如果我filtered_visit_times列表小于3
if len(filtered_visit_times) < 3:
# 我在filtered_visit_times第0个位置插入一条当前的时间
filtered_visit_times.insert(0, datetime.datetime.now())
# 我再将filtered_visit_times这个列表赋给VISIT_RECORD[user_ip]这个列表
self.VISIT_RECORD[user_ip] = filtered_visit_times
return True
return False