一、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'
)