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模塊)

 1 CACHES = {
 2  'default': {
 3   'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',  # 指定緩存使用的引擎
 4   'LOCATION': 'unique-snowflake',         # 寫在內存中的變量的惟一值 
 5   'TIMEOUT':300,             # 緩存超時時間(默認爲300秒,None表示永不過時)
 6   'OPTIONS':{
 7    'MAX_ENTRIES': 300,           # 最大緩存記錄的數量（默認300）
 8    'CULL_FREQUENCY': 3,          # 緩存到達最大個數以後，剔除緩存個數的比例，即：1/CULL_FREQUENCY（默認3）
 9   }  
10  }
11 }

內存緩存

 1 CACHES = {
 2  'default': {
 3   'BACKEND': 'django.core.cache.backends.filebased.FileBasedCache', #指定緩存使用的引擎
 4   'LOCATION': '/var/tmp/django_cache',        #指定緩存的路徑
 5   'TIMEOUT':300,              #緩存超時時間(默認爲300秒,None表示永不過時)
 6   'OPTIONS':{
 7    'MAX_ENTRIES': 300,            # 最大緩存記錄的數量（默認300）
 8    'CULL_FREQUENCY': 3,           # 緩存到達最大個數以後，剔除緩存個數的比例，即：1/CULL_FREQUENCY（默認3）
 9   }
10  }   
11 }

文件緩存

 1 CACHES = {
 2  'default': {
 3   'BACKEND': 'django.core.cache.backends.db.DatabaseCache',  # 指定緩存使用的引擎
 4   'LOCATION': 'cache_table',          # 數據庫表    
 5   'OPTIONS':{
 6    'MAX_ENTRIES': 300,           # 最大緩存記錄的數量（默認300）
 7    'CULL_FREQUENCY': 3,          # 緩存到達最大個數以後，剔除緩存個數的比例，即：1/CULL_FREQUENCY（默認3）
 8   }  
 9  }   
10 }
11 注意,建立緩存的數據庫表使用的語句:
12 
13 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',
]

Memcached緩存

  1 視圖：
  2 
  3 複製代碼
  4 from django.views.decorators.cache import cache_page
  5 import time
  6 from .models import *
  7 
  8 @cache_page(15)          #超時時間爲15秒
  9 def index(request):
 10 　　t=time.time()      #獲取當前時間
 11 　　bookList=Book.objects.all()
 12 　　return render(request,"index.html",locals())
 13 複製代碼
 14 模板(index.html):
 15 
 16 複製代碼
 17 <!DOCTYPE html>
 18 <html lang="en">
 19 <head>
 20     <meta charset="UTF-8">
 21     <title>Title</title>
 22 </head>
 23 <body>
 24 <h3>當前時間:-----{{ t }}</h3>
 25 
 26 <ul>
 27     {% for book in bookList %}
 28        <li>{{ book.name }}--------->{{ book.price }}$</li>
 29     {% endfor %}
 30 </ul>
 31 
 32 </body>
 33 </html>
 34 複製代碼
 35 上面的例子是基於內存的緩存配置,基於文件的緩存該怎麼配置呢??
 36 
 37 更改settings.py的配置
 38 
 39 複製代碼
 40 CACHES = {
 41  'default': {
 42   'BACKEND': 'django.core.cache.backends.filebased.FileBasedCache', # 指定緩存使用的引擎
 43   'LOCATION': 'E:\django_cache',          # 指定緩存的路徑
 44   'TIMEOUT': 300,              # 緩存超時時間(默認爲300秒,None表示永不過時)
 45   'OPTIONS': {
 46    'MAX_ENTRIES': 300,            # 最大緩存記錄的數量（默認300）
 47    'CULL_FREQUENCY': 3,           # 緩存到達最大個數以後，剔除緩存個數的比例，即：1/CULL_FREQUENCY（默認3）
 48   }
 49  }
 50 }
 51 複製代碼
 52 而後再次刷新瀏覽器,能夠看到在剛纔配置的目錄下生成的緩存文件
 53 
 54 經過實驗能夠知道,Django會以本身的形式把緩存文件保存在配置文件中指定的目錄中.
 55 
 56 4.2 全站使用緩存
 57 既然是全站緩存,固然要使用Django中的中間件.
 58 
 59 用戶的請求經過中間件,通過一系列的認證等操做,若是請求的內容在緩存中存在,則使用FetchFromCacheMiddleware獲取內容並返回給用戶
 60 
 61 當返回給用戶以前,判斷緩存中是否已經存在,若是不存在,則UpdateCacheMiddleware會將緩存保存至Django的緩存之中,以實現全站緩存
 62 
 63 複製代碼
 64 緩存整個站點，是最簡單的緩存方法
 65 
 66 在 MIDDLEWARE_CLASSES 中加入 「update」 和 「fetch」 中間件
 67 MIDDLEWARE_CLASSES = (
 68     ‘django.middleware.cache.UpdateCacheMiddleware’, #第一
 69     'django.middleware.common.CommonMiddleware',
 70     ‘django.middleware.cache.FetchFromCacheMiddleware’, #最後
 71 )
 72 「update」 必須配置在第一個
 73 「fetch」 必須配置在最後一個
 74 複製代碼
 75 修改settings.py配置文件
 76 
 77 
 78 複製代碼
 79 MIDDLEWARE_CLASSES = (
 80     'django.middleware.cache.UpdateCacheMiddleware',   #響應HttpResponse中設置幾個headers
 81     'django.contrib.sessions.middleware.SessionMiddleware',
 82     'django.middleware.common.CommonMiddleware',
 83     'django.middleware.csrf.CsrfViewMiddleware',
 84     'django.contrib.auth.middleware.AuthenticationMiddleware',
 85     'django.contrib.auth.middleware.SessionAuthenticationMiddleware',
 86     'django.contrib.messages.middleware.MessageMiddleware',
 87     'django.middleware.clickjacking.XFrameOptionsMiddleware',
 88     'django.middleware.security.SecurityMiddleware',
 89     'django.middleware.cache.FetchFromCacheMiddleware',   #用來緩存經過GET和HEAD方法獲取的狀態碼爲200的響應
 90 
 91 )
 92 
 93 
 94 CACHE_MIDDLEWARE_SECONDS=10
 95 複製代碼
 96 視圖函數：
 97 
 98 複製代碼
 99 from django.views.decorators.cache import cache_page
100 import time
101 from .models import *
102 
103 
104 def index(request):
105 
106      t=time.time()      #獲取當前時間
107      bookList=Book.objects.all()
108      return render(request,"index.html",locals())
109 
110 def foo(request):
111     t=time.time()      #獲取當前時間
112     return HttpResponse("HELLO:"+str(t))
113 複製代碼
114 模板(index.html)：
115 
116 複製代碼
117 <!DOCTYPE html>
118 <html lang="en">
119 <head>
120     <meta charset="UTF-8">
121     <title>Title</title>
122 </head>
123 <body>
124 <h3 style="color: green">當前時間:-----{{ t }}</h3>
125 
126 <ul>
127     {% for book in bookList %}
128        <li>{{ book.name }}--------->{{ book.price }}$</li>
129     {% endfor %}
130 </ul>
131 
132 </body>
133 </html>
134 複製代碼
135 其他代碼不變,刷新瀏覽器是10秒,頁面上的時間變化一次,這樣就實現了全站緩存.
136 
137 4.3局部視圖緩存
138 例子,刷新頁面時,整個網頁有一部分實現緩存
139 
140 views視圖函數
141 
142 複製代碼
143 from django.views.decorators.cache import cache_page
144 import time
145 from .models import *
146 def index(request):
147      t=time.time()      #獲取當前時間
148      bookList=Book.objects.all()
149      return render(request,"index.html",locals())
150 複製代碼
151 模板(index.html):
152 
153 複製代碼
154 {% load cache %}
155 <!DOCTYPE html>
156 <html lang="en">
157 <head>
158     <meta charset="UTF-8">
159     <title>Title</title>
160 </head>
161 <body>
162  <h3 style="color: green">不緩存:-----{{ t }}</h3>
163 
164 {% cache 2 'name' %}
165  <h3>緩存:-----:{{ t }}</h3>
166 {% endcache %}
167 
168 </body>
169 </html> 

緩存的使用

 1 string操做,redis中的string在內存中按照一個name對應一個value來存儲
 2 setname,value,ex=None,px=False,xx=False)
 3 在Redis中設置值,默認,不存在則建立,存在則修改
 4 參數:
 5 ex:過時時間(秒)
 6 px:過時時間(毫秒)
 7 nx:若是設置爲True,則只有name不存在時,當前set操做才執行,只存在就修改不了,執行沒效果
 8 xx:若是設置爲True,則只有name存在時,當前set操做才執行,值存在才能修改,值不存在不會設置新值
 9 setnx(name,value)
10 設置值,只有name不存在時,執行設置操做(添加),若是存在,不會修改
11 setex(name,value,time)
12 設置值,參數:time過時時間(數字秒,或timedelta對象)
13 psetex(name,time_ms,value)
14 設置值 參數:time_ms過時時間(數字毫秒)
15 mset(*args,**kwargs)
16 批量設置值 如:mset(k1='v1',k2='v2')或mget({'k1':'v1','k2':'v2'})
17 get(name)
18 獲取值
19 mget(key,*args)
20 批量獲取 mget('k1','k2')  或 mget(['k3','k4'])
21 getset(name,value)
22 設置新值並獲取原來的值
23 getrange(key,start,end)
24 獲取子序列(根據字節獲取,非字符)
25 參數:start:起始位置  end 結束位置
26 setrange(name, offset, value)
27 
28 # 修改字符串內容，從指定字符串索引開始向後替換（新值太長時，則向後添加）
29 # 參數：
30     # offset，字符串的索引，字節（一個漢字三個字節）
31     # value，要設置的值
32 strlen(name)
33 
34 # 返回name對應值的字節長度（一個漢字3個字節）
35 incr(self, name, amount=1)
36 
37 複製代碼
38 # 自增 name對應的值，當name不存在時，則建立name＝amount，不然，則自增。
39  
40 # 參數：
41     # name,Redis的name
42     # amount,自增數（必須是整數）
43  
44 # 注：同incrby
45 複製代碼
46 incrbyfloat(self, name, amount=1.0)
47 
48 # 自增 name對應的值，當name不存在時，則建立name＝amount，不然，則自增。
49  
50 # 參數：
51     # name,Redis的name
52     # amount,自增數（浮點型）
53 decr(self, name, amount=1)
54 
55 # 自減 name對應的值，當name不存在時，則建立name＝amount，不然，則自減。
56  
57 # 參數：
58     # name,Redis的name
59     # amount,自減數（整數）
60 append(key, value)
61 
62  
63 
64 # 在redis name對應的值後面追加內容
65  
66 # 參數：
67     key, redis的name
68     value, 要追加的字符串

Redis操做