版本控制，django缓存，跨域问题解决

复习

分页：
1. 简单分页	
2. 偏移分页
3. 加密分页

解析器：客户处理前端提交来的数据
	urlencode: body体中的数据格式： key=value&
    formdata编码：为区分文件和数据，有固定格式的分隔
    json: {"name":"aaa"}
    -- 全局使用
    	from rest_framework import JSONParser,FormParser,MultiPartParser

版本控制

四种方式 -- 内置的四种类

1. 基于get传参的方式 : QueryParameterVersioning ----->/?version=v1
# views.py
from rest_framework.versioning import QueryParameterVersioning
from django.http import HttpResponse
from rest_framework.views import APIView
class VersionTest(APIView):
    versioning_class=QueryParameterVersioning
    def get(self,request):
        version = request.version
        obj = request.versioning_scheme  #是QueryParameterVersioning的一个对象
        print(version,obj)
        return HttpResponse('ok')
    
# settings.py REST_FRAMEWORK字典中： --- 全局使用
'DEFAULT_VERSION': 'v1',            # 默认版本(从request对象里取不到，显示的默认值)
'ALLOWED_VERSIONS': ['v1', 'v2'],   # 允许的版本
'VERSION_PARAM': 'version'          # URL中获取值的key
 
# 局部使用： 视图类中配置
versioning_class=QueryParameterVersioning

# ---------------------------------------------------------------------------
2. 基于url的正则方式： URLPathVersioning ---> /v1/users/
from rest_framework.versioning import URLPathVersioning
#　1. 视图类中：局部使用
versioning_class= URLPathVersioning
# settings.py 全局使用
'DEFAULT_VERSIONING_CLASS':'rest_framework.versioning.URLPathVersioning',
'DEFAULT_VERSION': 'v1',            # 默认版本(从request对象里取不到，显示的默认值)
'ALLOWED_VERSIONS': ['v1', 'v2'],   # 允许的版本
'VERSION_PARAM': 'version'          # URL中获取值的key
# 2.url配置 (视图函数由参数 *args, **kwargs)
url(r'^(?P<version>[v1|v2]+)/verdiontest/')  
# -----------------------------------------------------------------------------

3. 基于accept 请求头方式： AcceptHeaderVersioning ---> Accept:application/json    version：1.0
    GET 请求，将以上两个键值对放在请求头中
from rest_framework.versioning import AcceptHeaderVersioning
#　视图类中：
versioning_class= AcceptHeaderVersioning

小结：
url 最常用，注意url ， 可以使用局部配置和全局配置两种方式，注意有名参数

Django 中的6种缓存

django缓存
-- 为了提高网站的并发量
-- 三种力度
	全站缓存 | 单页面缓存 | 页面的局部缓存
-- 6中缓存方式
    开发调试缓存
    内存缓存
    文件缓存
    数据库缓存
    Memcache缓存(使用python-memcached模块)
    Memcache缓存(使用pylibmc模块)
    经常使用的有文件缓存和Mencache缓存

    

Django 6中缓存的配置文件

1.2.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）
  },
 }
}

1.2.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）
  }  
 }
}

1.2.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）
  }
 }   
}

1.2.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）
  }  
 }   
}

注意,创建缓存的数据库表使用的语句:

python manage.py createcachetable

1.2.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',
]

1.2.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',
]

Memcached是基于内存的缓存,数据存储在内存中.所以如果服务器死机的话,数据就会丢失,所以Memcached一般与其他缓存配合使用

django 中使用缓存

第一步： 在settings.py 文件中配置 -- 选择上面的配置文件
		location 中的路径进行配置
第二步：使用缓存
# 单页面缓存-- 视图函数中使用缓存
添加装饰器
from django.views.decorators.cache import cache_page
@cache_page(5)
def cache_test(request):
    ctime= time.time()
    return render(request,'index.html',locals())
html页面：  {{ ctime }}

#局部缓存： html页面中
{% load cache %}
# 参数： 超时时间，key值(自定义的名字，用来表示这个局部内容)
{% cache 5 'text'}
需要缓存的代码块： {{ ctime }}
{% endcache %}

# 全站缓存：配置中间件
两个中间件，一个存，一个取
存： 放在最上边-- 重新写process_response 方法
'django.middleware.cache.UpdateCacheMiddleware'
...
'django.middleware.cache.FetchFromCacheMiddleware'
取： 放在最下边-- 重写process_request方法
还要配置缓存时间
CACHE_MIDDLEWARE_SECONDS=10

跨域问题

浏览器的 同源策略： 
-- 浏览器基本的安全策略
-- 当前页面只能给当前域的地址发送请求
-- ip + 端口 相同才是同源
--解决办法：
CORS跨域资源共享： 在服务端写东西允许其他域来访问
允许8000端口的访问--- 简单请求
def test(request):    
    obj = JsonResponse({1:'sff'})
    obj['Access-Control-Allow-Origin']='127.0.0.1:8000'
    return obj

CORS请求分两类： 简单请求， 复杂请求
简单请求： 符合如下两条-- 只发一次请求
    1. 请求方式： get,post,head
    2. HTTP头信息不超过以下字段：
    Accept | Accept-Language | Content-Language| Last-Event-ID|

非简单请求：
-- 先发options 预检请求，预检请求同意，再发真实的请求
obj = JsonResponse({1:'sff'})
obj['Access-Control-Allow-Origin']='*'
if request == 'OPTIONS':
  obj['Access-Control-Allow-Header']='*'
  obj['Access-Control-Allow-Method']='PUT,PATCH' # *
! 以上部分可以在中间件中设置，重写process_response方法

总结： 解决跨域问题就是写一个中间件，允许不同源请求数据
'''自定义一个中间件的步骤！！！！ '''
1. myscrf.py 文件中写一个中间件：
from django.utils.deprecation import MiddlewareMixin
class MyMiddleware(MiddlewareMixin):
    def process_response(self,request):    # 响应回去的
        #处理简单请求
        response['Access-Control-Allow-Origin']='*'
        # 处理非简单请求
        if  request.method=='OPTIONS':
            response['Access-Control-Allow-Header']='*'
            response['Access-Control-Allow-Method']='PUT,PATCH' # *
        return response
2.在settings文件中配置
from app.myscrf import MyMiddleware
'app.myscrf.MyMiddleware'  # 注意放在中间，如果配置了全站缓存
	

解决跨域： 方法二
安装django-cors-headers模块
在settings.py中配置
# 注册app
INSTALLED_APPS = [
	...
	'corsheaders'
]
# 添加中间件
MIDDLEWARE = [
	...
	'corsheaders.middleware.CorsMiddleware'
]
# 允许跨域源
CORS_ORIGIN_ALLOW_ALL = False
# 配置指定跨域域名
CORS_ORIGIN_WHITELIST = [
	'http://127.0.0.1:8080',
	'http://localhost:8080',
]