| 认证组件 |
使用：写一个认证类，继承BaseAuthentication
在类中写authenticate方法，把request对象传入
能从request对象中取出用户携带的token根据token判断是否登录过
如果登录过，返回两个值 user对象 ，token对象（或者其他自定义的对象）
如果没有登录过抛异常
from rest_framework.authentication import BaseAuthentication from app01 import models from rest_framework.exceptions import AuthenticationFailed class MyAuth(BaseAuthentication): def authenticate(self,request): # print('我是认证类中的方法，只要配置了，一定会执行') token = request.GET.get('token') token_obj=models.Token.objects.filter(token=token).first() if token_obj: #有值表示登录 # return #可以没有返回值它就直接接续掉这一次循环了 继续下一次循环 如果有值就解压赋值给self.user, self.auth self就是Request对象 return token_obj.user,token_obj #token_obj.user就是当前登录对象 正向查询 你就可以在任何地方调用当前登录用户了request.user 循环就直接解释了 else: #没有值表示没登录，抛异常 raise AuthenticationFailed('您没有登录')
全局使用
在settings中配置
# 全局使用认证功能 REST_FRAMEWORK={ "DEFAULT_AUTHENTICATION_CLASSES":["app01.MyAuths.MyAuth",]}
# 这里是固定写法：模块.继承AbstractUser的自定义User表
AUTH_USER_MODEL = 'user.User' 告诉django使用我们的表名
局部使用
在视图类中配置
authentication_classes= [MyAuth,] #认证
布局禁用
在视图类中配置
authentication_classes= []
update_or_create()有就跟新，没有就创建 查询的时候会查询k=v 有的话就把表中的{'token'：token}替换掉 没有就创建一条数据
参数：key=value,default={'token'：token}
uuid的使用：生成一个唯一的随机字符串
源码分析：
APIView中的dispatch--->slef.initial(认证，权限，频率）
--->self.perform_authentication(认证）
--->本质又调用新的reqeust对象的user方法
---->Request中进入找到user方法内部执行了self._authenticate(注意self是新的request对象）
for循环self.authenticators 对象自己的属性（for authenticator in self.authenticators）
实例化的时候是在APIView中dispatch中的
定位一下发现是继承了APIView类中去找get_authenticators方法
点位一下发现还是APIView中那么就是试图类对象调用这个方法属性查找顺序
就是我们配置在视图类中的一个认证类 列表中就是一个认证类对象
那么我们前面的for循环（for authenticator in self.authenticators）就是一个认证类对象
需要注意的是视图类中使用的认证类的时候如果第一个直接返回值这个for循环就结束了，如果视图类中的认证有多个的话后面的都不会执行了
| 权限 |
使用写一个权限类
from rest_framework.permissions import BasePermission class MyPermision(BasePermission): message = '不是超级用户，查看不了' #错误信息显示中文 def has_permission(self,request,view): #reques就是包装好的request,self在APIView类中就是产生的对象 view if request.user.user_type == 1: return True else:return False # "detail": "You do not have permission to perform this action."普通用户
局部使用
在视图类中配置:
permission_classes=[MyPermision,]
全局使用
在settings中配置
REST_FRAMEWORK={'DEFAULT_PERMISSION_CLASSES':['自定义的权限类']，}
局部禁用
在视图类中配置
permission_classes=[]
返回的提示是中文
权限类中配置 message=中文
源码分析 APIView---dispatch--initial--check_permissions
一个个权限类对象
对象调用自己方法 注释self定位一下发现是APIVeiw类中的那么self就是APIView对象写权限类的has_permission方法的时候传入request view参数
APIView调用方法 message就是错误信息抛出中文
| 视图 |
基本视图
路由
url(r'^publish/$', views.PublishView.as_view()), url(r'^publish/(?P<pk>d+)/$', views.PublishDetailView.as_view()),
视图
class PublishSerializers(serializers.ModelSerializer): class Meta: model=models.Publish fields='__all__' class PublishView(APIView): def get(self, request): publish_list = models.Publish.objects.all() bs = PublishSerializers(publish_list, many=True) # 序列化数据 return Response(bs.data) def post(self, request): # 添加一条数据 print(request.data) bs=PublishSerializers(data=request.data) if bs.is_valid(): bs.save() # 生成记录 return Response(bs.data) else: return Response(bs.errors) class PublishDetailView(APIView): def get(self,request,pk): publish_obj=models.Publish.objects.filter(pk=pk).first() bs=PublishSerializers(publish_obj,many=False) return Response(bs.data) def put(self,request,pk): publish_obj = models.Publish.objects.filter(pk=pk).first() bs=PublishSerializers(data=request.data,instance=publish_obj) if bs.is_valid(): bs.save() # update return Response(bs.data) else: return Response(bs.errors) def delete(self,request,pk): models.Publish.objects.filter(pk=pk).delete() return Response("")
第二种视图组件mixin类和generice类编写视图
路由
url(r'^publish/$', views.PublishView.as_view({'get': 'list', 'post': 'create'})), url(r'^publish/(?P<pk>d+)/$',views.PublishView.as_view({'get': 'retrieve', 'put': 'update', 'delete': 'destroy'})),
视图
from rest_framework.mixins import CreateModelMixin,RetrieveModelMixin,ListModelMixin,UpdateModelMixin,DestroyModelMixin from rest_framework.generics import GenericAPIView class PublishView(ListModelMixin,CreateModelMixin,GenericAPIView): queryset=models.Publish.objects.all() serializer_class=PublishSerializers def get(self, request): return self.list(request) def post(self, request): return self.create(request) class PublishDetailView(RetrieveModelMixin,UpdateModelMixin,DestroyModelMixin,GenericAPIView): queryset=models.Publish.objects.all() serializer_class=PublishSerializers def get(self,request,*args,**kwargs): return self.retrieve(request,*args,**kwargs) def put(self,request,*args,**kwargs): return self.update(request,*args,**kwargs) def delete(self,request,*args,**kwargs): return self.destroy(request,*args,**kwargs)
写ge和post,在其中调用父类的create或者list方法 list是获取多条
第三种视图组件使用generics 下ListCreateAPIView,RetrieveUpdateDestroyAPIView
from rest_framework.generics import ListCreateAPIView,RetrieveUpdateDestroyAPIView class PublishView(ListCreateAPIView): queryset=models.Publish.objects.all() serializer_class=PublishSerializers class PublishDetailView(RetrieveUpdateDestroyAPIView): queryset=models.Publish.objects.all() serializer_class=PublishSerializers
第四种视图组件使用ModelViewSet
路由
url(r'^publish/$', views.PublishView.as_view({'get':'list','post':'create'})), url(r'^publish/(?P<pk>d+)/$', views.PublishView.as_view({'get':'retrieve','put':'update','delete':'destroy'})),
视图
from rest_framework.viewsets import ModelViewSet class PublishView(ModelViewSet): queryset=models.Publish.objects.all() serializer_class=PublishSerializers
自定义视图方法
路由
url(r'^aa/$', views.PublishView.as_view({'get': 'aaa'})), url(r'^bb/$', views.PublishView.as_view({'get': 'bbb'})),
视图
from rest_framework.viewsets import ViewSetMixin from rest_framework.views import APIView # ViewSetMixin 重写了as_view方法 class Test(ViewSetMixin,APIView): def aaa(self,request): return Response()
ViewSetMixin重写了as_view方法，路由配置就改了，可以写成映射的形式{get：get_one}
as_view方法内部执行效果
通过反射的取值跟赋值，完成映射，根据请求方式执行相对应的方法（比如：get请求执行get_one方法，在路由中配置{get:get_one}）
| 频率组件 |
使用
写一个频率类，继承SimpleRateThrottle
重写get_cache_key，返回self.get_ident(request)
一定要记住配置一个scop='字符串'
第二部：在settings中配置
REST_FRAMEWORK = { 'DEFAULT_THROTTLE_RATES':{ 'lxx':'3/m' } }
局部使用
在视图类中配置：
throttle_classes=[Throttle,]
全局使用
在settings中配置
REST_FRAMEWORK={'DEFAULT_THROTTLE_CLASSES':['自己定义的频率类'],}
局部禁用
在视图类中配置
throttle_classes=[]
自定义频率
#（1）取出访问者ip # （2）判断当前ip不在访问字典里，添加进去，并且直接返回True,表示第一次访问，在字典里，继续往下走 # （3）循环判断当前ip的列表，有值，并且当前时间减去列表的最后一个时间大于60s，把这种数据pop掉，这样列表中只有60s以内的访问时间， # （4）判断，当列表小于3，说明一分钟以内访问不足三次，把当前时间插入到列表第一个位置，返回True，顺利通过 # （5）当大于等于3，说明一分钟内访问超过三次，返回False验证失败
代码
class MyThrottles(): VISIT_RECORD = {} def __init__(self): self.history=None def allow_request(self,request, view): #（1）取出访问者ip # print(request.META) ip=request.META.get('REMOTE_ADDR') import time ctime=time.time() # （2）判断当前ip不在访问字典里，添加进去，并且直接返回True,表示第一次访问 if ip not in self.VISIT_RECORD: self.VISIT_RECORD[ip]=[ctime,] return True self.history=self.VISIT_RECORD.get(ip) # （3）循环判断当前ip的列表，有值，并且当前时间减去列表的最后一个时间大于60s，把这种数据pop掉，这样列表中只有60s以内的访问时间， while self.history and ctime-self.history[-1]>60: self.history.pop() # （4）判断，当列表小于3，说明一分钟以内访问不足三次，把当前时间插入到列表第一个位置，返回True，顺利通过 # （5）当大于等于3，说明一分钟内访问超过三次，返回False验证失败 if len(self.history)<3: self.history.insert(0,ctime) return True else: return False def wait(self): import time ctime=time.time() return 60-(ctime-self.history[-1])
源码分析
def check_throttles(self, request): for throttle in self.get_throttles(): if not throttle.allow_request(request, self): self.throttled(request, throttle.wait()) def throttled(self, request, wait): #抛异常，可以自定义异常，实现错误信息的中文显示 raise exceptions.Throttled(wait)
class SimpleRateThrottle(BaseThrottle): # 咱自己写的放在了全局变量，他的在django的缓存中 cache = default_cache # 获取当前时间，跟咱写的一样 timer = time.time # 做了一个字符串格式化， cache_format = 'throttle_%(scope)s_%(ident)s' scope = None # 从配置文件中取DEFAULT_THROTTLE_RATES，所以咱配置文件中应该配置，否则报错 THROTTLE_RATES = api_settings.DEFAULT_THROTTLE_RATES def __init__(self): if not getattr(self, 'rate', None): # 从配置文件中找出scope配置的名字对应的值，比如咱写的‘3/m’,他取出来 self.rate = self.get_rate() # 解析'3/m',解析成 3 m self.num_requests, self.duration = self.parse_rate(self.rate) # 这个方法需要重写 def get_cache_key(self, request, view): """ Should return a unique cache-key which can be used for throttling. Must be overridden. May return `None` if the request should not be throttled. """ raise NotImplementedError('.get_cache_key() must be overridden') def get_rate(self): if not getattr(self, 'scope', None): msg = ("You must set either `.scope` or `.rate` for '%s' throttle" % self.__class__.__name__) raise ImproperlyConfigured(msg) try: # 获取在setting里配置的字典中的之，self.scope是 咱写的luffy return self.THROTTLE_RATES[self.scope] except KeyError: msg = "No default throttle rate set for '%s' scope" % self.scope raise ImproperlyConfigured(msg) # 解析 3/m这种传参 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) num, period = rate.split('/') num_requests = int(num) # 只取了第一位，也就是 3/mimmmmmmm也是代表一分钟 duration = {'s': 1, 'm': 60, 'h': 3600, 'd': 86400}[period[0]] return (num_requests, duration) # 逻辑跟咱自定义的相同 def allow_request(self, request, view): """ Implement the check to see if the request should be throttled. On success calls `throttle_success`. On failure calls `throttle_failure`. """ if self.rate is None: return True self.key = self.get_cache_key(request, view) if self.key is None: return True self.history = self.cache.get(self.key, []) self.now = self.timer() # Drop any requests from the history which have now passed the # throttle duration while self.history and self.history[-1] <= self.now - self.duration: self.history.pop() if len(self.history) >= self.num_requests: return self.throttle_failure() return self.throttle_success() # 成功返回true，并且插入到缓存中 def throttle_success(self): """ Inserts the current request's timestamp along with the key into the cache. """ self.history.insert(0, self.now) self.cache.set(self.key, self.history, self.duration) return True # 失败返回false def throttle_failure(self): """ Called when a request to the API has failed due to throttling. """ return False def wait(self): """ Returns the recommended next request time in seconds. """ if self.history: remaining_duration = self.duration - (self.now - self.history[-1]) else: remaining_duration = self.duration available_requests = self.num_requests - len(self.history) + 1 if available_requests <= 0: return None return remaining_duration / float(available_requests) SimpleRateThrottle源码分析