昨日回顾

1 频率限制
    -写一个类，继承SimpleRateThrottle，重写get_cache_key，
        返回什么就以什么做限制（限制ip，限制用户id，手机号），
    -再写一个类属性scope='字符串'， 需要跟配置文件中对应 '字符串'：'5/m'
    -局部配置，全局配置
    # 注意：若是以ip限制全局配置，那么所有的接口总计不能超过指定的次数，就不单是某个接口次数限制
    
2 过滤和排序
    -内置过滤类：SearchFilter
    -内置排序类：OrderingFilter
    -配置在继承GenericAPIView+ListModelMixin及其子类的view接口中，类属性：filter_backends=[]
    -配置相应的字段
        -search_fields=['name']   
        -ordering_fields = ['price']   
        
3 第三方过滤类
    -配置在类属性上：filter_backends = [DjangoFilterBackend]
    -配置字段：filterset_fields=['name','price']
    -http://127.0.0.1:8000/books/?name=红楼梦&price=12
            
4 自定义过滤类
    -自己写一个类，继承BaseFilterBackend，重写filter_queryset，返回queryset对象，queryset是过滤后的
    -配置在继承GenericAPIView+ListModelMixin及其子类，类属性：filter_backends
    
5 分页功能
	-三个分页类
		PageNumberPagination：基本分页  ?page=1&size=2
			-四个类属性
		LimitOffsetPagination：偏移分页 ?limit=3&offset=2
			-四个类属性
		CursorPagination：游标分页      选择上一页和下一页
			-三个类属性
			-cursor_query_param = 'cursor'  # 查询条件
			-page_size = 2  # 每页显示多少条
		-ordering = 'id' #按谁排序
	-只需要配置在继承GenericAPIView+ListModelMixin及其子类，类属性：pagination_class

今日内容

1. drf整体流程

# drf处于的位置：路由匹配成功，进视图类之前

# 整体处理流程：
	1.包装新的request对象
    2.处理编码（urlencoded，formdata，json）
    3.三大认证（顺序：认证、权限、频率）（*****）
    4.进入视图类：
    	-4.1 若是继承（APIView）（*****）
            -去模型中取数据
            -序列化（*****）
            -返回数据         
    	-4.2 若是继承（GenericAPIView+ListModelMixin）（*****）
        	-去模型中取数据
            -进行过滤和排序
            -分页
            -序列化（*****）
            -返回数据         
    -5.处理了响应（浏览器，json）
    -6.处理了全局异常

2. 源码分析--认证、频率、权限

2.1 认证源码

# 1.入口：APIView的dispatch()中--->self.initial()中处理三大认证--->认证类的代码：self.perform_authentication(request)

# 2.self.perform_authentication(request)--->就是APIView的perform_authentication()
    def perform_authentication(self, request):
        request.user # 执行了新的request对象的user方法
        
# 3.Request类的user方法
    @property
    def user(self):
        if not hasattr(self, '_user'):
            with wrap_attributeerrors():
                # 核心就是这句话，是Request的_authenticate()方法
                self._authenticate()  
        return self._user
        
# 4.Request类的_authenticate(self)方法   (核心)
    def _authenticate(self):
        for authenticator in self.authenticators: # self.authenticators是个列表，列表中放了一个个认证类的对象
            try:
                # self是request，所以自定义认证类的authenticate，有两个参数(self,request)，第二个参数request给了这里的self
                user_auth_tuple = authenticator.authenticate(self) # 执行认证类的authenticate方法
            except exceptions.APIException:
                self._not_authenticated()
                raise
                
            if user_auth_tuple is not None:
                self._authenticator = authenticator
                self.user, self.auth = user_auth_tuple  # 解压赋值,后续的request对象就有user属性了
                return
            	# 源码可知：若是写了多个认证类，只要有一个认证类中认证通过，返回了user和token，后续的认证类就不会for循环执行了

        self._not_authenticated()
       
	
# 5.Request类的self.authenticators属性    是多个认证类对象的列表
	-是在Request初始化的时候，传入的
    -Request类是在什么时候初始化的---》APIView的dispatch中的刚开始位置
    -APIView的dispatch()---> request = self.initialize_request(request, *args, **kwargs)

    
# 6.APIView的self.initialize_request方法
	def initialize_request(self, request, *args, **kwargs):
        return Request(
            request,
            parsers=self.get_parsers(),
            authenticators=self.get_authenticators(),# APIView的
            negotiator=self.get_content_negotiator(),
            parser_context=parser_context
        )
    
# 7.APIView的get_authenticators方法
    def get_authenticators(self):
        # 列表中放了一个个认证类的对象
        return [auth() for auth in self.authentication_classes]

2.2 权限源码

# 1.入口：APIView的dispatch()中--->self.initial()中处理三大认证--->权限类的代码self.check_permissions(request)

# 2.APIView的check_permissions方法
    def check_permissions(self, request):
        for permission in self.get_permissions():  # 列表，是一个个视图类中配置的权限类的对象
            if not permission.has_permission(request, self):
                self.permission_denied(
                    request,
                    message=getattr(permission, 'message', None),
                    code=getattr(permission, 'code', None)
                )
                
# 3.APIView的self.get_permissions():
    def get_permissions(self):
        # 列表里放了一个个权限类的对象
        return [permission() for permission in self.permission_classes]
    
# 4.权限认证失败，返回中文
	-在权限类中配置message即可（给对象，类都可以）

2.3 频率源码

# 1.入口：APIView的dispatch()中--->self.initial()中处理三大认证--->频率类的代码self.check_throttles(request)

# 2.APIView的self.check_throttles(request)
    def check_throttles(self, request):
        throttle_durations = []
        for throttle in self.get_throttles():  # 列表，是一个个视图类中配置的频率类的对象
            # 如果被限制了，就把剩余时间 追加到 throttle_durations 限制持续时间 列表中
            if not throttle.allow_request(request, self):
                throttle_durations.append(throttle.wait())  
                
# 3.APIView的self.get_throttles()
       def get_throttles(self):
        # 列表里放了一个个频率类的对象
        return [throttle() for throttle in self.throttle_classes]
    
# 从频率的源码可知：
若是自定义的频率类 是继承SimpleRateThrottle的，可以直接将限制的值 写在频率限制类中
	THROTTLE_RATES = {'ip_m_3': '3/m'}
    
    
    
# SimpleRateThrottle源码分析：
    def get_rate(self):  # 根据配置的限制值的key:scope，从THROTTLE_RATES中 取出限制值：rate
        """
        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  m
        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
		
        # 从缓存中取出 存放IP访问时间 的列表，若是初次访问，缓存为空，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，将第一次记录清除，不再算作一次计数
        # 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，代表可以访问
        return self.throttle_success()
    
    def throttle_success(self):  # 将当前时间插入到history列表的开头，将history列表、key、过期时间作为数据存到缓存中
        """
        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

3. 自定义全局异常处理

# 1.自定义一个全局异常处理函数
def common_exception_handler(exc, context):
	"""
	# 一般会将错误信息添加到日志：
    通过参数 exc可获取错误提示信息，通过参数context可获取错误详细信息
    str(exec)  # 错误提示信息
    str(context['view'])  # 错误发生的视图
    context['request'].META.get('REMOTE_ADDR')  # IP地址
    context['request'].user.id  # 用户的ID
	"""
    
    # 1. 执行drf默认的异常处理
    response = exception_handler(exc, context)
    # 2.判断是否能被默认的异常处理捕获
    if response:
        # 2.1 若能被默认的捕获到，会返回一个Response对象出来，我们可.data 拿出原本默认要返回给前端的数据，再结合自己的格式 指定返回
        return Response(data={'code': 9998, 'msg': response.data})
    else:
        # 2.2 若不能被默认的捕获到，会返回None，就自定义处理 返回给前端
        return Response(data={'code': 9999, 'msg': '服务器异常，请联系系统管理员'})
    
 # 2.在配置文件中
REST_FRAMEWORK = {
    'EXCEPTION_HANDLER': 'app01.exceptions.common_exception_handler', 
}

4. 自动生成接口文档

# 前后的分离
	-前端一批人
    	-根本不知道你写了什么接口，请求参数什么样，响应数据什么样
        -使用什么编码都不知道
    -后端一批人
    	-我们写了很多接口
        
        
# 需要写接口文档（不同公司有规范）
	-1 公司有接口文档平台，后端在平台上录入接口
    -2 使用第三方接口文档平台，后端写了在平台录入
    	-Yapi:开源
    -3 使用md，word文档写，写完传到git上
    -4 自动生成接口文档（swagger，coreapi）
    	-通过swagger自动生成后导出，再导入到Yapi中

        
# coreapi 第三方模块--自动生成接口文档
# 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:
            修改图书的阅读量
            """
        
# 4 在配置文件中配置       
REST_FRAMEWORK = {
    'DEFAULT_SCHEMA_CLASS': 'rest_framework.schemas.coreapi.AutoSchema',
}

补充

1.函数显示传参类型和返回值

# python3.5以上版本，typing模块提高代码健壮性  (公司常见写的方式)

from typing import List, Tuple, Dict

def test(a: int, string: str, f: float, b: bool) -> Tuple[List, Tuple, Dict, bool]:
    ll=[1,2,3,4]
    tup = (string, a, string)
    dic = {"xxx": f}
    boo = b
    return ll, tup, dic, boo

print(test(12, "lqz", 2.3, False))

作业

# 1 三个认证的源码---》自己捋一遍

# 2 写一个全局异常处理函数，保证无论出什么异常，前端都返回固定格式
def common_exception(exc, context):
    # 第一步：记录异常信息到日志
    print(
        f'异常视图：{str(context["view"])}  访问IP：{context["request"].META.get("REMOTE_ADDR")} '
        f'访问用户ID：{context["request"].user.id} 异常信息：{str(exc)}')

    # 第二步：调用rest_framework 的异常捕获
    response = exception_handler(exc, context)
    # 第三步：判断是否能被内置的捕获到
    if response:
        # 若能，将内部返回的数据取出来，再加上我们自己的格式 返回给前端
        return Response(data={'code': 9999, 'msg': response.data})
    return Response(data={'code': 99998, 'msg': '系统出错，请联系管理员'})

# 3 试一下coreapi自动生成接口文档

# 4 给你一个地址，上地址看看Yapi怎么用