drf版本控制redis基础

内置的版本控制类

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

基于url的get传参方式:QueryParameterVersioning      如:/user?version=v1

基于url的正则方式:URLPathVersioning              /v1/user/

基于accept请求头方式:AcceptHeaderVersioning    Accept:application/json;version=1

基于主机名方法:HostNameVersioning       v1.example.com

基于django路由系统的namespace:NamespaceVersioning       example.com/v1/users/

局部使用

在CBV类中加入

versioning_class = URLPathVersioning

全局使用

REST_FRAMEWORK = {'DEFAULT_VERSIONING_CLASS':'rest_framework.versioning.QueryParameterVersioning',

'DEFAULT_VERSION':'v1',   默认版本(request中无法取到)

'ALLOWED_VERSIONS':['v1','v2'],    (允许的版本)

'VERSION_PARAM':'version'}   URL中获取值的key

基于正则的方式:

from django.conf.urls import url,include

from web.views import TestView

urlpatterns = [ url(r'^(?P<version>[v1|v2]+)/test/',TestView.as_view(),name='test'),]

获取版本: request.version

获取版本管理的类:  request.versioning_scheme

源码分析

执行determine_version,返回两个值,放到request对象里

version,scheme =self.determine_version(request,*args,**kwargs)

request.version,request.versioning_scheme = version,scheme

def determine_version(self,request,*args,**kwargs):

　　if self.versioning_class is None:

　　　　return (None,None)

　　scheme =self.versioning_class()

　　return (scheme.determine_version(request,*args,**kwargs),scheme)

django缓存

为了提高网站并发量

三种粒度;

　　全站缓存,单页面缓存,页面中布局缓存

6中缓存机制

django中使用缓存

第一步:在settings中配置(缓存方式),已缓存到文件举例

　　CACHE= {'default':{'BACKEND':'django.core.cache.backends.filebased.FileBaedCache',指定缓存使用的引擎

'LOCATION':'/var/tmp/django_cache', 指定缓存的路径

'TIMEOUT':300,   缓存超时时间(默认为300秒,None表示永不过期)

'OPTIONS':{'MAX_ENTRIES':300,'CULL_FREQUENCY':3,}}} 最大缓存的数量300, 缓存到达最大个数之后,剔除缓存个数的比例

第二部使用缓存

使用单页面缓存(使用装饰器):

from django.views.decorators.cache import cache_page

@cache_page(5)

def cache_test(request):

　　ctime = time.time()

　　return render(request,'index.html',locals())

页面局部缓存

{% load cache %}

第一个参数是超时时间,第二个参数是key值,唯一的标志

{% cache 5 'tt' %}

{{ ctime }}

{% endcache %}

全站缓存:配置中间件

配置两个中间件:

django.middleware.cache.UpdateCacheMiddleware'...

django.middleware.cache.FetchFromCacheMiddleware'

配置缓存时间

CACHE_MIDDLEWARE_SECONDS=10

缓存存储的数据格式

unique-snowflake={index:regre}

跨域问题

同源策略

浏览器基本的安全策略

当前页面只能朝当前域的地址发送请求

不同的域:ip+端口+协议  都相同才是同一个域

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

简单请求只发一次请求

费简单请求发两次:一次是OPTIONS预检请求,预检通过再发第二次真实请求,

以后处理跨域问题(可以使用第三方的django-cors-headers):

写一个中间件:

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

在settings中配置

redis

mysql,oracle:关系型数据库

redis,mongodb:菲关系型数据库/nosql

redis存储在内存内  mongodb存储到硬盘上  

redis一般用来做:

做缓存

session数据

游戏排行榜

对速度要求比较高的数据的存储

做消息队列

redis是key-value的存储,支持持久化,类字典,有五大数据类型:

字符串:

列表:

字典:

集合:

有序集合:

redis = { k1:'123',字符串,可:[1,2,3]列表,k3:{1,2,3}集合,k4:{name:lqz,age:12}字典/hash表,k5:{('lqz',18),('egon',33)有序集合}}

比较redis和Memcached

redis支持五大数据类型 redis支持持久化,单进程,单线程,速度非常快

Memcached不能持久化,只支持字符串

python操作redis

安装redis模块

快速使用

import redis

conn = redis.Redis(host='127.0.0.1',port=6379)

name=conn.get('name')

redis连接池

首先新建模块

import redis

POOL = redis.ConnectionPool(host='127.0.0.1',port=6379.max_connections=1000)

使用连接池

from conn_pool import POOL

conn = redis.Redis(connection_pool=POOL)

Django中的6中缓存方式

开发者调试缓存

内存缓存

文件缓存

数据库缓存

Memcached缓存(使用python-memcache模块)

Memcache缓存(使用pylibmc模块)

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

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

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

Memcached是Django原生支持的缓存系统.要使用Memcached,需要下载Memcached的支持库python-memcached或pylibmc.

settings.py文件配置
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',
]

视图：

复制代码
from django.views.decorators.cache import cache_page
import time
from .models import *

@cache_page(15)          #超时时间为15秒
def index(request):
　　t=time.time()      #获取当前时间
　　bookList=Book.objects.all()
　　return render(request,"index.html",locals())
复制代码
模板(index.html):

复制代码
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<h3>当前时间:-----{{ t }}</h3>

<ul>
    {% for book in bookList %}
       <li>{{ book.name }}--------->{{ book.price }}$</li>
    {% endfor %}
</ul>

</body>
</html>
复制代码
上面的例子是基于内存的缓存配置,基于文件的缓存该怎么配置呢??

更改settings.py的配置

复制代码
CACHES = {
 'default': {
  'BACKEND': 'django.core.cache.backends.filebased.FileBasedCache', # 指定缓存使用的引擎
  'LOCATION': 'E:django_cache',          # 指定缓存的路径
  'TIMEOUT': 300,              # 缓存超时时间(默认为300秒,None表示永不过期)
  'OPTIONS': {
   'MAX_ENTRIES': 300,            # 最大缓存记录的数量（默认300）
   'CULL_FREQUENCY': 3,           # 缓存到达最大个数之后，剔除缓存个数的比例，即：1/CULL_FREQUENCY（默认3）
  }
 }
}
复制代码
然后再次刷新浏览器,可以看到在刚才配置的目录下生成的缓存文件

通过实验可以知道,Django会以自己的形式把缓存文件保存在配置文件中指定的目录中.

4.2 全站使用缓存
既然是全站缓存,当然要使用Django中的中间件.

用户的请求通过中间件,经过一系列的认证等操作,如果请求的内容在缓存中存在,则使用FetchFromCacheMiddleware获取内容并返回给用户

当返回给用户之前,判断缓存中是否已经存在,如果不存在,则UpdateCacheMiddleware会将缓存保存至Django的缓存之中,以实现全站缓存

复制代码
缓存整个站点，是最简单的缓存方法

在 MIDDLEWARE_CLASSES 中加入 “update” 和 “fetch” 中间件
MIDDLEWARE_CLASSES = (
    ‘django.middleware.cache.UpdateCacheMiddleware’, #第一
    'django.middleware.common.CommonMiddleware',
    ‘django.middleware.cache.FetchFromCacheMiddleware’, #最后
)
“update” 必须配置在第一个
“fetch” 必须配置在最后一个
复制代码
修改settings.py配置文件


复制代码
MIDDLEWARE_CLASSES = (
    'django.middleware.cache.UpdateCacheMiddleware',   #响应HttpResponse中设置几个headers
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.common.CommonMiddleware',
    'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.auth.middleware.SessionAuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
    'django.middleware.security.SecurityMiddleware',
    'django.middleware.cache.FetchFromCacheMiddleware',   #用来缓存通过GET和HEAD方法获取的状态码为200的响应

)


CACHE_MIDDLEWARE_SECONDS=10
复制代码
视图函数：

复制代码
from django.views.decorators.cache import cache_page
import time
from .models import *


def index(request):

     t=time.time()      #获取当前时间
     bookList=Book.objects.all()
     return render(request,"index.html",locals())

def foo(request):
    t=time.time()      #获取当前时间
    return HttpResponse("HELLO:"+str(t))
复制代码
模板(index.html)：

复制代码
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<h3 style="color: green">当前时间:-----{{ t }}</h3>

<ul>
    {% for book in bookList %}
       <li>{{ book.name }}--------->{{ book.price }}$</li>
    {% endfor %}
</ul>

</body>
</html>
复制代码
其余代码不变,刷新浏览器是10秒,页面上的时间变化一次,这样就实现了全站缓存.

4.3局部视图缓存
例子,刷新页面时,整个网页有一部分实现缓存

views视图函数

复制代码
from django.views.decorators.cache import cache_page
import time
from .models import *
def index(request):
     t=time.time()      #获取当前时间
     bookList=Book.objects.all()
     return render(request,"index.html",locals())
复制代码
模板(index.html):

复制代码
{% load cache %}
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
 <h3 style="color: green">不缓存:-----{{ t }}</h3>

{% cache 2 'name' %}
 <h3>缓存:-----:{{ t }}</h3>
{% endcache %}

</body>
</html> 

string操作,redis中的string在内存中按照一个name对应一个value来存储
setname,value,ex=None,px=False,xx=False)
在Redis中设置值,默认,不存在则创建,存在则修改
参数:
ex:过期时间(秒)
px:过期时间(毫秒)
nx:如果设置为True,则只有name不存在时,当前set操作才执行,只存在就修改不了,执行没效果
xx:如果设置为True,则只有name存在时,当前set操作才执行,值存在才能修改,值不存在不会设置新值
setnx(name,value)
设置值,只有name不存在时,执行设置操作(添加),如果存在,不会修改
setex(name,value,time)
设置值,参数:time过期时间(数字秒,或timedelta对象)
psetex(name,time_ms,value)
设置值 参数:time_ms过期时间(数字毫秒)
mset(*args,**kwargs)
批量设置值 如:mset(k1='v1',k2='v2')或mget({'k1':'v1','k2':'v2'})
get(name)
获取值
mget(key,*args)
批量获取 mget('k1','k2')  或 mget(['k3','k4'])
getset(name,value)
设置新值并获取原来的值
getrange(key,start,end)
获取子序列(根据字节获取,非字符)
参数:start:起始位置  end 结束位置
setrange(name, offset, value)

# 修改字符串内容，从指定字符串索引开始向后替换（新值太长时，则向后添加）
# 参数：
    # offset，字符串的索引，字节（一个汉字三个字节）
    # value，要设置的值
strlen(name)

# 返回name对应值的字节长度（一个汉字3个字节）
incr(self, name, amount=1)

复制代码
# 自增 name对应的值，当name不存在时，则创建name＝amount，否则，则自增。
 
# 参数：
    # name,Redis的name
    # amount,自增数（必须是整数）
 
# 注：同incrby
复制代码
incrbyfloat(self, name, amount=1.0)

# 自增 name对应的值，当name不存在时，则创建name＝amount，否则，则自增。
 
# 参数：
    # name,Redis的name
    # amount,自增数（浮点型）
decr(self, name, amount=1)

# 自减 name对应的值，当name不存在时，则创建name＝amount，否则，则自减。
 
# 参数：
    # name,Redis的name
    # amount,自减数（整数）
append(key, value)

 

# 在redis name对应的值后面追加内容
 
# 参数：
    key, redis的name
    value, 要追加的字符串