一.rest-framework之版本控制 二、Django缓存 三、跨域问题 四、drf分页器 五、响应器 六、url控制器

一、rest-framework之版本控制

1.作用

用于版本的控制

2.内置的版本控制

from rest_framework.versioning import QueryParameterVersioning,AcceptHeaderVersioning,NamespaceVersioning,URLPathVersioning

#基于url的get传参方式：QueryParameterVersioning------>如：/versiontest/?version=v1

#基于url的正则方式：URLPathVersioning------>/v1/versiontest/  (推荐使用)

#基于 accept 请求头方式：AcceptHeaderVersioning-->Accept: application/json;version=v1

#基于主机名方法：HostNameVersioning------>v1.example.com

#基于django路由系统的namespace：NamespaceVersioning------>example.com/v1/versiontest/

'''
基于正则的方式,需要修改urls.py
url(r'^(?P<version>[v1|v2]+)/versiontest/', views.VersionTest.as_view()),

'''
基于 accept 请求头方式
Headers KEY:Accept VALUE:application/json;version=v1
'''

3.局部使用

'''
在视图类中配置
    versioning_class=URLPathVersioning

4.全局使用

'''
在settings.py中配置
REST_FRAMEWORK = {
    #默认versioning_class
    'DEFAULT_VERSIONING_CLASS':'rest_framework.versioning.QueryParameterVersioning',
    'DEFAULT_VERSION': 'v1',            # 默认版本(从request对象里取不到，显示的默认值)
    'ALLOWED_VERSIONS': ['v1', 'v2'],   # 允许的版本
    'VERSION_PARAM': 'version'          # URL中获取值的key
}
'''

5.使用

'''
使用时局部全局都要配置
在视图类的方法中取出版本号:request.version
'''

二、Django缓存

1.目的

提高网站的并发量

2.三种粒度

全站缓存
单页面缓存
页面中局部缓存

3.Django中的6种缓存方式

•开发调试缓存
•内存缓存
•文件缓存
•数据库缓存
•Memcache缓存(使用python-memcached模块)
•Memcache缓存(使用pylibmc模块)
经常使用的有文件缓存和Mencache缓存

4.Django中使用缓存

•第一步:在setting.py中配置
4.1.1 开发调试(此模式为开发调试使用,实际上不执行任何操作)
'''
CACHES = {
 'default': {
  'BACKEND': 'django.core.cache.backends.dummy.DummyCache',  # 缓存后台使用的引擎
  'TIMEOUT': 300,          # 缓存超时时间（默认300秒，None表示永不过期，0表示立即过期）
  'OPTIONS':{
   'MAX_ENTRIES': 300,     # 最大缓存记录的数量（默认300）
   'CULL_FREQUENCY': 3,    # 缓存到达最大个数之后，剔除缓存个数的比例，即：1/CULL_FREQUENCY（默认3）
  },
 }
}
'''

4.1.2 内存缓存(将缓存内容保存至内存区域中)
'''
CACHES = {
 'default': {
  'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',  # 指定缓存使用的引擎
  'LOCATION': 'unique-snowflake',         # 写在内存中的变量的唯一值
  'TIMEOUT':300,             # 缓存超时时间(默认为300秒,None表示永不过期)
  'OPTIONS':{
   'MAX_ENTRIES': 300,           # 最大缓存记录的数量（默认300）
   'CULL_FREQUENCY': 3,          # 缓存到达最大个数之后，剔除缓存个数的比例，即：1/CULL_FREQUENCY（默认3）
  }
 }
}
'''

4.1.3 文件缓存(把缓存数据存储在文件中)
'''
CACHES = {
 'default': {
  'BACKEND': 'django.core.cache.backends.filebased.FileBasedCache', #指定缓存使用的引擎
  'LOCATION': '/var/tmp/django_cache',        #指定缓存的路径
  'TIMEOUT':300,              #缓存超时时间(默认为300秒,None表示永不过期)
  'OPTIONS':{
   'MAX_ENTRIES': 300,            # 最大缓存记录的数量（默认300）
   'CULL_FREQUENCY': 3,           # 缓存到达最大个数之后，剔除缓存个数的比例，即：1/CULL_FREQUENCY（默认3）
  }
 }
}
'''

4.1.4 数据库缓存(把缓存数据存储在数据库中)
'''
CACHES = {
 'default': {
  'BACKEND': 'django.core.cache.backends.db.DatabaseCache',  # 指定缓存使用的引擎
  'LOCATION': 'cache_table',          # 数据库表
  'OPTIONS':{
   'MAX_ENTRIES': 300,           # 最大缓存记录的数量（默认300）
   'CULL_FREQUENCY': 3,          # 缓存到达最大个数之后，剔除缓存个数的比例，即：1/CULL_FREQUENCY（默认3）
  }
 }
}
'''

4.1.5 Memcache缓存(使用python-memcached模块连接memcache)
Memcached是Django原生支持的缓存系统.要使用Memcached,需要下载Memcached的支持库python-memcached或pylibmc.
'''
CACHES = {
 'default': {
  'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache', # 指定缓存使用的引擎
  'LOCATION': '192.168.10.100:11211',         # 指定Memcache缓存服务器的IP地址和端口
  'OPTIONS':{
   'MAX_ENTRIES': 300,            # 最大缓存记录的数量（默认300）
   'CULL_FREQUENCY': 3,           # 缓存到达最大个数之后，剔除缓存个数的比例，即：1/CULL_FREQUENCY（默认3）
  }
 }
}
'''
LOCATION也可以配置成如下:
'''
'LOCATION': 'unix:/tmp/memcached.sock',   # 指定局域网内的主机名加socket套接字为Memcache缓存服务器
'LOCATION': [         # 指定一台或多台其他主机ip地址加端口为Memcache缓存服务器
 '192.168.10.100:11211',
 '192.168.10.101:11211',
 '192.168.10.102:11211',
]
'''

4.1.6 Memcache缓存(使用pylibmc模块连接memcache)
'''
settings.py文件配置
 CACHES = {
  'default': {
   'BACKEND': 'django.core.cache.backends.memcached.PyLibMCCache',  # 指定缓存使用的引擎
   'LOCATION':'192.168.10.100:11211',         # 指定本机的11211端口为Memcache缓存服务器
   'OPTIONS':{
    'MAX_ENTRIES': 300,            # 最大缓存记录的数量（默认300）
    'CULL_FREQUENCY': 3,           # 缓存到达最大个数之后，剔除缓存个数的比例，即：1/CULL_FREQUENCY（默认3）
   },
  }
 }
'''
LOCATION也可以配置成'LOCATION': '/tmp/memcached.sock',  # 指定某个路径为缓存目录
'LOCATION': [       # 分布式缓存,在多台服务器上运行Memcached进程,程序会把多台服务器当作一个单独的缓存,而不会在每台服务器上复制缓存值
 '192.168.10.100:11211',
 '192.168.10.101:11211',
 '192.168.10.102:11211',
]
如下:
'''
'LOCATION': '/tmp/memcached.sock',  # 指定某个路径为缓存目录
'LOCATION': [       # 分布式缓存,在多台服务器上运行Memcached进程,程序会把多台服务器当作一个单独的缓存,而不会在每台服务器上复制缓存值
 '192.168.10.100:11211',
 '192.168.10.101:11211',
 '192.168.10.102:11211',
]
'''
Memcached是基于内存的缓存,数据存储在内存中.所以如果服务器死机的话,数据就会丢失,所以Memcached一般与其他缓存配合使用

•第二步:使用缓存
4.2.1 单页面使用(使用装饰器)
'''
from django.views.decorators.cache import cache_page
import time
@cache_page(5)  #缓存时间为5秒
def cache_test(request):
    print('走视图函数')
    c_time=time.time()
    return render(request,'index.html',locals())
'''

4.2.2 页面局部缓存
在前端页面中
{% load cache %}
#传两个参数:第一个参数是超时时间，第二个参数是key值(随便写),唯一的标志#
{% cache 5 'rrr' %}
    当前时间是:{{ c_time }}
{% endcache %}

4.2.3 全站缓存
-配置两个中间件
'django.middleware.cache.UpdateCacheMiddleware'
...
'django.middleware.cache.FetchFromCacheMiddleware'

“update” 必须配置在第一个
“fetch” 必须配置在最后一个

-配置缓存时间
CACHE_MIDDLEWARE_SECONDS=5

三、跨域问题

1.同源策略

1.浏览器基本的安全策略
2.当前页面只能朝当前域的地址发送请求
--不同的域:ip+端口+协议 都相同才是同一个域

2.CORS 跨域资源共享

简单请求和非简单请求
只要符合如下两条,就是简单请求,否则是非简单请求
(1)请求方式是以下三种方法之一:
    HEAD
    GET
    POST
(2)HTTP的头信息不超过以下几种字段:
    Accept
    Accept-Language
    Content-Language
    Last-Event-ID
    Content-Type：只限于三个值application/x-www-form-urlencoded、multipart/form-data、text/plain 

3.简单请求

简单请求只发送一次请求

如何处理简单请求?
'''
from django.http import JsonResponse
def test(request):
    print('请求来了!')
    obj = JsonResponse({'name':'lzq','age':'24'})

    #允许 http://127.0.0.1:8008 朝自己发送请求
    obj['Access-Control-Allow-Origin']='http://127.0.0.1:8008'

    #允许所有地址朝自己发送请求
    obj['Access-Control-Allow-Origin']='*'

    return obj
'''

4.非简单请求

非简单请求发送两次:一次是OPTIONS预检请求,预检请求同意发送,再发送第二次请求,这次就是真实的请求.用于数据的传输.
如何处理非简单请求?
'''
from django.http import JsonResponse
def test(request):
    print('请求来了!')
    obj = JsonResponse({'name':'lzq','age':'24'})

    obj['Access-Control-Allow-Origin']='*'

    if request.method == 'OPTIONS':
        obj['Access-Control-Allow-Headers']='*'
        obj['Access-Control-Allow-Methods']='*'

    return obj
'''

5.最终处理方法

1.写一个中间件
在app下建立一个MyMiddle.py文件
from django.utils.deprecation import MiddlewareMixin
class MyMiddleware(MiddlewareMixin):
    def process_response(self,request,response):
        #处理了简单请求
        response['Access-Control-Allow-Origin'] = '*'
        #处理非简单请求
        if request.method=='OPTIONS':
            response['Access-Control-Allow-Headers']='*'
            response['Access-Control-Allow-Methods']='*'

        return response
2.配置到settings.py的中间件中

也可以用第三方的django-cors-headers插件来处理跨域问题

四、drf分页器

1 简单分页（查看第n页，每页显示n条）
    -使用方法
        -1 导入PageNumberPagination类
            from rest_framework.pagination import PageNumberPagination
        -2 实例化产生一个分页类对象,不需要传参数
            -page_pagination = PageNumberPagination()
        -3 需要配置四个参数:page_size,page_query_param,page_size_query_param,max_page_size
            -page_size必须指定:在setting中指定或者直接赋值,这个是每页的页数
        -4 调用下面的方法,返回ret数据,第一个参数是要分页的queryset对象,第二个参数是request对象
            ret = page_pagination.paginate_queryset(book_list, request, self)
        -5 再序列化,就是序列化返回的数据,也就是ret
            例如:
            book_list = models.Book.object.all()
            不使用分页:
            book_ser = BookSerializer(instance=book_list,many = True)

            使用分页:
            book_ser = BookSerializer(instance=ret,many = True)

     -类中需要掌握的几个属性
           -page_size:控制每页显示条数
        -page_query_param:控制查询第几页的查询参数,
            -比如page_query_param='xx'
            -http://127.0.0.1:8000/books/?xx=2  表示查询第二页的数据
        -page_size_query_param:控制每页最大显示的条数
            -比如page_pagination.page_size_query_param='max'
            -http://127.0.0.1:8000/books/?xx=2&max=6   表示查询第二页的数据,每页显示6条
        -max_page_size:控制每页最大显示的条数
            -比如:page_pagination.max_page_size=7
            -http://127.0.0.1:8000/books/?max=1000    最多显示7条

2 偏移分页（在第n个位置，向后查看n条数据）
    -使用方式:
        -1 导入LimitOffsetPagination类
        from rest_framework.pagination import LimitOffsetPagination
        -2 实例化产生一个分页类对象,不需要传参数
        -page_pagination = LimitOffsetPagination()
        -3 需要配置四个参数
        -4 调用下面的方法,返回ret数据,第一个参数是要分页的queryset对象,第二个参数是request对象
        ret = page_pagination.paginate_queryset(book_list, request, self)
        -5 再序列化,就是序列化返回的数据,也就是ret
            例如:
                book_list = models.Book.object.all()
                不使用分页:
                book_ser = BookSerializer(instance=book_list,many = True)

                使用分页:
                book_ser = BookSerializer(instance=ret,many = True)

    -重点的参数
        -default_limit:默认每页显示的条数,默认偏移的数量
            -比如:default_limit=5
                -http://127.0.0.1:8000/books/    就会显示5条数据

        -limit_query_param:往后偏移多少条
            -就用默认值:limit

        -offset_query_param:标杆值
            -用默认值:offset
            limit_query_param+offset_query_param联合起来用:
            -访问:http://127.0.0.1:8000/books/?limit=1&offset=5  表示:以数据的第5条作为标杆,往后偏移1条

        -max_limit:最大偏移的条数(最大取出的条数)

3 CursorPagination（加密分页，只能看上一页和下一页，速度快）
    -使用方式:
        -1 导入CursorPageination类
               from rest_framework.pagination import CursorPageination
        -2 实例化产生一个分页类对象,不需要传参数
            -page_pagination = CursorPageination()
        -3 配置重要参数
        -4 调用下面的方法,返回ret数据,第一个参数是要分页的queryset对象,第二个参数是request对象
            ret = page_pagination.paginate_queryset(book_list, request, self)
        -5 再序列化,就是序列化返回的数据,也就是ret
            例如:
                book_list = models.Book.object.all()
                不使用分页:
                book_ser = BookSerializer(instance=book_list,many = True)

                使用分页:
                book_ser = BookSerializer(instance=ret,many = True)

      -重点参数:
        -page_size:每页显示的条数
        -cursor_query_param:不需要改动
        -ordering:按什么字段排序(必须指定)
    -可以通过get_paginated_response返回,这样返回结果中带上一页和下一页的链接地址
        page_pagination.get_paginated_response(book_ser.data) 方法的用法

五、响应器

响应器(不需要改,默认就可以)
    不同请求方式,响应回去的页面,数据格式是不同的
    -局部使用:
        #可以响应配置的数据类型
        在视图类中配置:
        renderer_classes = [JSONRenderer,BrowsableAPIRenderer]
    -全局使用:
        在setting中配置:
            'DEFAULT_RENDERER_CLASSES': (
                'rest_framework.renderers.JSONRenderer',
                'rest_framework.renderers.BrowsableAPIRenderer',
            ),

六、url控制器

url控制器
-自定义路由（原始方式）
    from django.conf.urls import url
    from app01 import views
    urlpatterns = [
        url(r'^books/$', views.BookView.as_view()),
        url(r'^books/(?P<pk>\d+)$', views.BookDetailView.as_view()),
    ]

-半自动路由（视图类继承ModelViewSet）
    from django.conf.urls import url
    from app01 import views
    urlpatterns = [
        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.py中
    from rest_framework import routers
    #生成一个router对象
    router=routers.DefaultRouter()
    # 两个参数，一个是匹配的路由，一个是视图中写的CBV的类
    router.register('books',views.BooksView)
    urlpatterns = [
           url(r'',include(router.urls))
    ]

七、解析器

-解析器做什么用的?
    -能够解析前端传递的数据格式:urlencode,formdata,json格式
-默认情况下解析所有格式
    内置了三种解析器
    from rest_framework.parsers import JSONParser
    from rest_framework.parsers import FormParser
    from rest_framework.parsers import MultiPartParser

-解析器的局部使用
    再视图类中配置:
        #只能解析json格式
        parser_classes=[JSONParser]

-全局使用:
    在setting中配置(配置几种就可以解析几种数据类型):
        'DEFAULT_PARSER_CLASSES': (
            'rest_framework.parsers.JSONParser',
            'rest_framework.parsers.FormParser',
            'rest_framework.parsers.MultiPartParser'
        )