redis資料型別使用
阿新 • • 發佈：2020-08-23
目錄
redis 簡介
redis為什麼那麼快：
首先，採用了多路複用io阻塞機制
然後，資料結構簡單，操作節省時間
最後，執行在記憶體中，自然速度快
redis: 記憶體資料庫(讀寫快)、非關係型(操作資料方便、資料固定) mysql: 硬碟資料庫(資料持久化)、關係型(操作資料間關係、可以不同組合) 大量訪問的臨時資料，redis資料庫更優 redis: 操作字串、列表、字典、無序集合、有序集合 | 支援資料持久化(資料丟失可以找回(預設持久化，主動持久化save)、可以將資料同步給mysql) | 高併發支援 memcache: 操作字串 | 不支援資料持久化 | 併發量小 1. 使用Redis有哪些好處？ (1) 速度快，因為資料存在記憶體中，類似於HashMap，HashMap的優勢就是查詢和操作的時間複雜度都是O(1) (2) 支援豐富資料型別，支援string，list，set，sorted set，hash (3) 支援事務，操作都是原子性，所謂的原子性就是對資料的更改要麼全部執行，要麼全部不執行 (4) 豐富的特性：可用於快取，訊息，按key設定過期時間，過期後將會自動刪除 2. redis相比memcached有哪些優勢？ (1) memcached所有的值均是簡單的字串，redis作為其替代者，支援更為豐富的資料型別 (2) redis的速度比memcached快很多 (3) redis可以持久化其資料 3. redis常見效能問題和解決方案： (1) Master最好不要做任何持久化工作，如RDB記憶體快照和AOF日誌檔案 (2) 如果資料比較重要，某個Slave開啟AOF備份資料，策略設定為每秒同步一次 (3) 為了主從複製的速度和連線的穩定性，Master和Slave最好在同一個區域網內 (4) 儘量避免在壓力很大的主庫上增加從庫 (5) 主從複製不要用圖狀結構，用單向連結串列結構更為穩定，即：Master <- Slave1 <- Slave2 <- Slave3... 這樣的結構方便解決單點故障問題，實現Slave對Master的替換。如果Master掛了，可以立刻啟用Slave1做Master，其他不變。 4. MySQL裡有2000w資料，redis中只存20w的資料，如何保證redis中的資料都是熱點資料 相關知識：redis 記憶體資料集大小上升到一定大小的時候，就會施行資料淘汰策略。redis 提供 6種資料淘汰策略： voltile-lru：從已設定過期時間的資料集（server.db[i].expires）中挑選最近最少使用的資料淘汰 volatile-ttl：從已設定過期時間的資料集（server.db[i].expires）中挑選將要過期的資料淘汰 volatile-random：從已設定過期時間的資料集（server.db[i].expires）中任意選擇資料淘汰 allkeys-lru：從資料集（server.db[i].dict）中挑選最近最少使用的資料淘汰 allkeys-random：從資料集（server.db[i].dict）中任意選擇資料淘汰 no-enviction（驅逐）：禁止驅逐資料 5. Memcache與Redis的區別都有哪些？ 1)、儲存方式 Memecache把資料全部存在記憶體之中，斷電後會掛掉，資料不能超過記憶體大小。 Redis有部份存在硬碟上，這樣能保證資料的永續性。 2)、資料支援型別 Memcache對資料型別支援相對簡單。 Redis有複雜的資料型別。 3），value大小 redis最大可以達到1GB，而memcache只有1MB 6. Redis 常見的效能問題都有哪些？如何解決？ 1).Master寫記憶體快照，save命令排程rdbSave函式，會阻塞主執行緒的工作，當快照比較大時對效能影響是非常大的，會間斷性暫停服務，所以Master最好不要寫記憶體快照。 2).Master AOF持久化，如果不重寫AOF檔案，這個持久化方式對效能的影響是最小的，但是AOF檔案會不斷增大，AOF檔案過大會影響Master重啟的恢復速度。Master最好不要做任何持久化工作，包括記憶體快照和AOF日誌檔案，特別是不要啟用記憶體快照做持久化,如果資料比較關鍵，某個Slave開啟AOF備份資料，策略為每秒同步一次。 3).Master呼叫BGREWRITEAOF重寫AOF檔案，AOF在重寫的時候會佔大量的CPU和記憶體資源，導致服務load過高，出現短暫服務暫停現象。 4). Redis主從複製的效能問題，為了主從複製的速度和連線的穩定性，Slave和Master最好在同一個區域網內 7, redis 最適合的場景 Redis最適合所有資料in-momory的場景，雖然Redis也提供持久化功能，但實際更多的是一個disk-backed的功能，跟傳統意義上的持久化有比較大的差別，那麼可能大家就會有疑問，似乎Redis更像一個加強版的Memcached，那麼何時使用Memcached,何時使用Redis呢? 如果簡單地比較Redis與Memcached的區別，大多數都會得到以下觀點： 1 、Redis不僅僅支援簡單的k/v型別的資料，同時還提供list，set，zset，hash等資料結構的儲存。 2 、Redis支援資料的備份，即master-slave模式的資料備份。 3 、Redis支援資料的持久化，可以將記憶體中的資料保持在磁碟中，重啟的時候可以再次載入進行使用。 （1）、會話快取（Session Cache） 最常用的一種使用Redis的情景是會話快取（session cache）。用Redis快取會話比其他儲存（如Memcached）的優勢在於：Redis提供持久化。當維護一個不是嚴格要求一致性的快取時，如果使用者的購物車資訊全部丟失，大部分人都會不高興的，現在，他們還會這樣嗎？ 幸運的是，隨著 Redis 這些年的改進，很容易找到怎麼恰當的使用Redis來快取會話的文件。甚至廣為人知的商業平臺Magento也提供Redis的外掛。 （2）、全頁快取（FPC） 除基本的會話token之外，Redis還提供很簡便的FPC平臺。回到一致性問題，即使重啟了Redis例項，因為有磁碟的持久化，使用者也不會看到頁面載入速度的下降，這是一個極大改進，類似PHP本地FPC。 再次以Magento為例，Magento提供一個外掛來使用Redis作為全頁快取後端。 此外，對WordPress的使用者來說，Pantheon有一個非常好的外掛 wp-redis，這個外掛能幫助你以最快速度載入你曾瀏覽過的頁面。 （3）、佇列 Reids在記憶體儲存引擎領域的一大優點是提供 list 和 set 操作，這使得Redis能作為一個很好的訊息佇列平臺來使用。Redis作為佇列使用的操作，就類似於本地程式語言（如Python）對 list 的 push/pop 操作。 如果你快速的在Google中搜索“Redis queues”，你馬上就能找到大量的開源專案，這些專案的目的就是利用Redis建立非常好的後端工具，以滿足各種佇列需求。例如，Celery有一個後臺就是使用Redis作為broker，你可以從這裡去檢視。 （4），排行榜/計數器 Redis在記憶體中對數字進行遞增或遞減的操作實現的非常好。集合（Set）和有序集合（Sorted Set）也使得我們在執行這些操作的時候變的非常簡單，Redis只是正好提供了這兩種資料結構。所以，我們要從排序集合中獲取到排名最靠前的10個使用者–我們稱之為“user_scores”，我們只需要像下面一樣執行即可： 當然，這是假定你是根據你使用者的分數做遞增的排序。如果你想返回使用者及使用者的分數，你需要這樣執行： ZRANGE user_scores 0 10 WITHSCORES Agora Games就是一個很好的例子，用Ruby實現的，它的排行榜就是使用Redis來儲存資料的，你可以在這裡看到。 （5）、釋出/訂閱 最後（但肯定不是最不重要的）是Redis的釋出/訂閱功能。釋出/訂閱的使用場景確實非常多。我已看見人們在社交網路連線中使用，還可作為基於釋出/訂閱的指令碼觸發器，甚至用Redis的釋出/訂閱功能來建立聊天系統！（不，這是真的，你可以去核實）。 Redis提供的所有特性中，我感覺這個是喜歡的人最少的一個，雖然它為使用者提供如果此多功能。
Redis安裝
linux下安裝
wget http://download.redis.io/releases/redis-3.0.6.tar.gz
tar xzf redis-3.0.6.tar.gz
cd redis-3.0.6
make
## 啟動服務端
src/redis-server
## 啟動客戶端
src/redis-cli
redis> set foo bar
OK
redis> get foo
"bar"
Windows下安裝
地址：https://github.com/microsoftarchive/redis/releases
Redis操作
啟動服務
前提：前往一個方便管理redis持久化檔案的邏輯再啟動服務：dump.rdb 1）前臺啟動服務 >: redis-server 2）後臺啟動服務 >: redis-server --service-start 注）Linux系統後臺啟動（或是修改配置檔案，建議採用方式） >: redis-server & 3）配置檔案啟動前臺服務 >: redis-server 配置檔案的絕對路徑 4）配置檔案啟動後臺服務 注）windows系統預設按Redis安裝包下的redis.windows-service.conf配置檔案啟動 >: redis-server --service-start 注）Linux系統可以完全自定義配置檔案(redis.conf)後臺啟動 >: redis-server 配置檔案的絕對路徑 & windows系統 1）前臺啟動 i）開啟終端切換到redis安裝目錄 >: cd C:\Apps\Redis ii）啟動服務 >: redis-server redis.windows.conf 2）後臺啟動 i）開啟終端切換到redis安裝目錄 >: cd C:\Apps\Redis ii）啟動服務（後面的配置檔案可以省略） >: redis-server --service-start redis.windows-service.conf
密碼管理
1）提倡在配置檔案中配置，採用配置檔案啟動
requirepass 密碼
2）當服務啟動後，並且連入資料庫（redis資料庫不能輕易重啟），可以再改當前服務的密碼(服務重啟，密碼重置)
config set requirepass 新密碼
3）已連入資料庫，可以檢視當前資料庫服務密碼
config get requirepass
連線資料庫
1）預設連線：-h預設127.0.0.1，-p預設6379，-n預設0，-a預設無 >: redis-cli 2）完整連線： >: redis-cli -h ip地址 -p 埠號 -n 資料庫編號 -a 密碼 3）先連線，後輸入密碼 >: redis-cli -h ip地址 -p 埠號 -n 資料庫編號 >: auth 密碼
切換資料庫
1）在連入資料庫後執行
>: select 資料庫編號
關閉服務
1）先連線資料庫，再關閉redis服務
>: redis-cli -h ip地址 -p 埠號 -n 資料庫編號 -a 密碼
>: shutdown
2）直接連線資料庫並關閉redis服務
>: redis-cli -h ip地址 -p 埠號 -n 資料庫編號 -a 密碼 shutdown
清空redis資料庫
1）連線資料庫執行
>: flushall
資料持久化
1）配置檔案預設配置
save 900 1 # 超過900秒有1個鍵值對操作，會自動呼叫save完成資料持久化
save 300 10 # 超過300秒有10個鍵值對操作，會自動呼叫save完成資料持久化
save 60 10000 # 超過60秒有10000個鍵值對操作，會自動呼叫save完成資料持久化
2）安全機制
# 當redis服務不可控宕機，會預設呼叫一下save完成資料持久化（如果資料量過大，也可能存在部分資料丟失）
3）主動持久化
>: save # 連入資料庫時，主動呼叫save完成資料持久化
注：資料持久化預設儲存檔案 dump.rdb，儲存路徑預設為啟動redis服務的當前路徑
redis相關配置
1）繫結的ip地址，多個ip用空格隔開
bind 127.0.0.1
2）埠，預設6379，一般不做修改
port 6379
3）是否以守護程序啟動，預設為no，一般改為yes代表後臺啟動（windows系統不支援）
daemonize no
4）定義日誌級別，預設值為notice，有如下4種取值：
debug（記錄大量日誌資訊，適用於開發、測試階段）
verbose（較多日誌資訊）
notice（適量日誌資訊，使用於生產環境）
warning（僅有部分重要、關鍵資訊才會被記錄）
loglevel notice
5）配置日誌檔案保持地址，預設列印在命令列終端的視窗上
如果填寫 "./redis.log" 就會在啟動redis服務的終端所在目錄下，用redis.log記錄redis日誌
logfile ""
eg）終端首先切斷到log資料夾所在目錄(一般就可以採用redis的安裝目錄，也可以自定義)，再啟動reids服務
logfile "./log/redis.log"
6）資料庫個數，預設是16個，沒特殊情況，不建議修改
databases 16
7）資料持久化
save 900 1 # 超過900秒有1個鍵值對操作，會自動呼叫save完成資料持久化
save 300 10 # 超過300秒有10個鍵值對操作，會自動呼叫save完成資料持久化
save 60 10000 # 超過60秒有10000個鍵值對操作，會自動呼叫save完成資料持久化
8）資料庫持久化到硬碟失敗，redis會立即停止接收使用者資料，讓使用者知道redis持久化異常，避免資料災難發生(重啟redis即可)，預設為yes，不能做修改
stop-writes-on-bgsave-error yes
9）消耗cpu來壓縮資料進行持久化，資料量小，但會消耗cpu效能，根據實際情況可以做調整
rdbcompression yes
10）增持cpu 10%效能銷燬來完成持久化資料的校驗，可以取消掉
rdbchecksum yes
11）持久化儲存的檔名稱
dbfilename dump.rdb
12）持久化儲存檔案的路徑，預設是啟動服務的終端所在目錄
dir ./
13）reids資料庫密碼
requirepass 密碼
Redis資料型別
資料操作：字串、列表/陣列、雜湊(字典)、無序集合、有序(排序)集合
有序集合：遊戲排行榜
字串：
set key value
get key
mset k1 v1 k2 v2 ...
mget k1 k2 ...
setex key exp value
incrby key increment
列表：
rpush key value1 value2 ...
lpush key value1 value2 ...
lrange key bindex eindex
lindex key index
lpop key | rpop key
linsert key before|after old_value new_value
雜湊：
hset key field value
hget key field
hmset key field1 value1 field2 value2 ...
hmget key field1 field2
hkeys key
hvals key
hdel key field
集合：
sadd key member1 member2 ...
sdiff key1 key2 ...
sdiffstore newkey key1 key2 ...
sinter key1 key2 ...
sunion key1 key2 ...
smembers key
spop key
有序集合：
zadd key grade1 member1 grade2 member2 ...
zincrby key grade member
zrange key start end
zrevrange key start end
python使用redis
pip3 install redis
# 普通連線
import redis
# decode_responses=True得到的結果會自動解碼（不是二進位制資料）
r = redis.Redis(host='127.0.0.1', port=6379, db=1, password=None, decode_responses=True)
r.set('foo', 'Bar')
print(r.get('foo'))
# 連線池使用
import redis
pool = redis.ConnectionPool(host='127.0.0.1', port=6379, db=1, max_connections=100, password=None, decode_responses=True)
r = redis.Redis(connection_pool=pool)
r.set('foo', 'Bar')
print(r.get('foo'))
# 選擇資料庫
import redis
pool = redis.ConnectionPool(host='127.0.0.1', port=6379, db=1, max_connections=100, password=None, decode_responses=True)
r = redis.Redis(connection_pool=pool)
r.execute_command('select 1')
# 快取使用：要額外安裝 django-redis
# 1.將快取儲存位置配置到redis中：settings.py
CACHES = {
"default": {
"BACKEND": "django_redis.cache.RedisCache",
"LOCATION": "redis://127.0.0.1:6379/0",
"OPTIONS": {
"CLIENT_CLASS": "django_redis.client.DefaultClient",
"CONNECTION_POOL_KWARGS": {"max_connections": 100},
"DECODE_RESPONSES": True,
"PASSWORD": "",
}
}
}
# 2.操作cache模組直接操作快取：views.py
from django.core.cache import cache # 結合配置檔案實現插拔式
# 存放token，可以直接設定過期時間
cache.set('token', 'header.payload.signature', 300)
# 取出token
token = cache.get('token')
字串操作
set(name, value, ex=None, px=None, nx=False, xx=False)
在Redis中設定值，預設，不存在則建立，存在則修改
引數：
ex，過期時間（秒）
px，過期時間（毫秒）
nx，如果設定為True，則只有name不存在時，當前set操作才執行,值存在，就修改不了，執行沒效果
xx，如果設定為True，則只有name存在時，當前set操作才執行，值存在才能修改，值不存在，不會設定新值
setnx(name, value)
設定值，只有name不存在時，執行設定操作（新增）,如果存在，不會修改
setex(name, value, time)
設定值
引數：
time，過期時間（數字秒 或 timedelta物件）
mset(*args, **kwargs)
批量設定值
如：
mset(k1='v1', k2='v2')
或
mget({'k1': 'v1', 'k2': 'v2'})
get(name)
獲取值
mget(keys, *args)
批量獲取
如：
mget('k1', 'k2')
或
r.mget(['k3', 'k4'])
getset(name, value)
設定新值並獲取原來的值
getrange(key, start, end)
獲取子序列（根據位元組獲取，非字元）
引數：
name，Redis 的 name
start，起始位置（位元組）
end，結束位置（位元組）
如： "劉清政" ，0-3表示 "劉"
setrange(name, offset, value)
修改字串內容，從指定字串索引開始向後替換（新值太長時，則向後新增）
引數：
offset，字串的索引，位元組（一個漢字三個位元組）
value，要設定的值
setbit(name, offset, value)
對name對應值的二進位制表示的位進行操作
引數：
name，redis的name
offset，位的索引（將值變換成二進位制後再進行索引）
value，值只能是 1 或 0
注：如果在Redis中有一個對應： n1 = "foo"，
那麼字串foo的二進位制表示為：01100110 01101111 01101111
所以，如果執行 setbit('n1', 7, 1)，則就會將第7位設定為1，
那麼最終二進位制則變成 01100111 01101111 01101111，即："goo"
getbit(name, offset)
獲取name對應的值的二進位制表示中的某位的值 （0或1）
bitcount(key, start=None, end=None)
獲取name對應的值的二進位制表示中 1 的個數
引數：
key，Redis的name
start，位起始位置
end，位結束位置
bitop(operation, dest, *keys)
獲取多個值，並將值做位運算，將最後的結果儲存至新的name對應的值
引數：
operation,AND（並） 、 OR（或） 、 NOT（非） 、 XOR（異或）
dest, 新的Redis的name
*keys,要查詢的Redis的name
如：
bitop("AND", 'new_name', 'n1', 'n2', 'n3')
獲取Redis中n1,n2,n3對應的值，然後講所有的值做位運算（求並集），然後將結果儲存 new_name 對應的值中
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, 要追加的字串
Hash操作
hset(name, key, value)
# name對應的hash中設定一個鍵值對（不存在，則建立；否則，修改）
# 引數：
# name，redis的name
# key，name對應的hash中的key
# value，name對應的hash中的value
# 注：
# hsetnx(name, key, value),當name對應的hash中不存在當前key時則建立（相當於新增）
hmset(name, mapping)
# 在name對應的hash中批量設定鍵值對
# 引數：
# name，redis的name
# mapping，字典，如：{'k1':'v1', 'k2': 'v2'}
# 如：
# r.hmset('xx', {'k1':'v1', 'k2': 'v2'})
hget(name,key)
# 在name對應的hash中獲取根據key獲取value
hmget(name, keys, *args)
# 在name對應的hash中獲取多個key的值
# 引數：
# name，reids對應的name
# keys，要獲取key集合，如：['k1', 'k2', 'k3']
# *args，要獲取的key，如：k1,k2,k3
# 如：
# r.mget('xx', ['k1', 'k2'])
# 或
# print(r.hmget('xx', 'k1', 'k2'))
hgetall(name)
獲取name對應hash的所有鍵值
print(re.hgetall('xxx').get(b'name'))
hlen(name)
獲取name對應的hash中鍵值對的個數
hkeys(name)
獲取name對應的hash中所有的key的值
hvals(name)
獲取name對應的hash中所有的value的值
hexists(name, key)
檢查name對應的hash是否存在當前傳入的key
hdel(name,*keys)
將name對應的hash中指定key的鍵值對刪除
print(re.hdel('xxx','sex','name'))
hincrby(name, key, amount=1)
# 自增name對應的hash中的指定key的值，不存在則建立key=amount
# 引數：
# name，redis中的name
# key， hash對應的key
# amount，自增數（整數）
hincrbyfloat(name, key, amount=1.0)
# 自增name對應的hash中的指定key的值，不存在則建立key=amount
# 引數：
# name，redis中的name
# key， hash對應的key
# amount，自增數（浮點數）
# 自增name對應的hash中的指定key的值，不存在則建立key=amount
hscan(name, cursor=0, match=None, count=None)
# 增量式迭代獲取，對於資料大的資料非常有用，hscan可以實現分片的獲取資料，並非一次性將資料全部獲取完，從而放置記憶體被撐爆
# 引數：
# name，redis的name
# cursor，遊標（基於遊標分批取獲取資料）
# match，匹配指定key，預設None 表示所有的key
# count，每次分片最少獲取個數，預設None表示採用Redis的預設分片個數
# 如：
# 第一次：cursor1, data1 = r.hscan('xx', cursor=0, match=None, count=None)
# 第二次：cursor2, data1 = r.hscan('xx', cursor=cursor1, match=None, count=None)
# ...
# 直到返回值cursor的值為0時，表示資料已經通過分片獲取完畢
hscan_iter(name, match=None, count=None)
# 利用yield封裝hscan建立生成器，實現分批去redis中獲取資料
# 引數：
# match，匹配指定key，預設None 表示所有的key
# count，每次分片最少獲取個數，預設None表示採用Redis的預設分片個數
# 如：
# for item in r.hscan_iter('xx'):
# print(item)
List操作
List操作，redis中的List在在記憶體中按照一個name對應一個List來儲存。
lpush(name,values)
# 在name對應的list中新增元素，每個新的元素都新增到列表的最左邊
# 如：
# r.lpush('oo', 11,22,33)
# 儲存順序為: 33,22,11
# 擴充套件：
# rpush(name, values) 表示從右向左操作
lpushx(name,value)
# 在name對應的list中新增元素，只有name已經存在時，值新增到列表的最左邊
# 更多：
# rpushx(name, value) 表示從右向左操作
llen(name)
name對應的list元素的個數
linsert(name, where, refvalue, value))
# 在name對應的列表的某一個值前或後插入一個新值
# 引數：
# name，redis的name
# where，BEFORE或AFTER(小寫也可以)
# refvalue，標杆值，即：在它前後插入資料（如果存在多個標杆值，以找到的第一個為準）
# value，要插入的資料
r.lset(name, index, value)
# 對name對應的list中的某一個索引位置重新賦值
# 引數：
# name，redis的name
# index，list的索引位置
# value，要設定的值
r.lrem(name, count, value)
# 在name對應的list中刪除指定的值
# 引數：
# name，redis的name
# count count=0，刪除列表中所有的指定值；
# count=2,從前到後，刪除2個；
# count=-2,從後向前，刪除2個
# value，要刪除的值
lpop(name)
# 在name對應的列表的左側獲取第一個元素並在列表中移除，返回值則是第一個元素
# 更多：
# rpop(name) 表示從右向左操作
lindex(name, index)
在name對應的列表中根據索引獲取列表元素
lrange(name, start, end)
# 在name對應的列表分片獲取資料
# 引數：
# name，redis的name
# start，索引的起始位置
# end，索引結束位置 print(re.lrange('aa',0,re.llen('aa')))
ltrim(name, start, end)
# 在name對應的列表中移除沒有在start-end索引之間的值
# 引數：
# name，redis的name
# start，索引的起始位置
# end，索引結束位置（大於列表長度，則代表不移除任何）
rpoplpush(src, dst)
# 從一個列表取出最右邊的元素，同時將其新增至另一個列表的最左邊
# 引數：
# src，要取資料的列表的name
# dst，要新增資料的列表的name
blpop(keys, timeout)
# 將多個列表排列，按照從左到右去pop對應列表的元素
# 引數：
# keys，redis的name的集合
# timeout，超時時間，當元素所有列表的元素獲取完之後，阻塞等待列表內有資料的時間（秒）, 0 表示永遠阻塞
# 更多：
# r.brpop(keys, timeout)，從右向左獲取資料爬蟲實現簡單分散式：多個url放到列表裡，往裡不停放URL，程式迴圈取值，但是隻能一臺機器執行取值，可以把url放到redis中，多臺機器從redis中取值，爬取資料，實現簡單分散式
brpoplpush(src, dst, timeout=0)
# 從一個列表的右側移除一個元素並將其新增到另一個列表的左側
# 引數：
# src，取出並要移除元素的列表對應的name
# dst，要插入元素的列表對應的name
# timeout，當src對應的列表中沒有資料時，阻塞等待其有資料的超時時間（秒），0 表示永遠阻塞
自定義增量迭代
# 由於redis類庫中沒有提供對列表元素的增量迭代，如果想要迴圈name對應的列表的所有元素，那麼就需要：
# 1、獲取name對應的所有列表
# 2、迴圈列表
# 但是，如果列表非常大，那麼就有可能在第一步時就將程式的內容撐爆，所有有必要自定義一個增量迭代的功能：
import redis
conn=redis.Redis(host='127.0.0.1',port=6379)
# conn.lpush('test',*[1,2,3,4,45,5,6,7,7,8,43,5,6,768,89,9,65,4,23,54,6757,8,68])
# conn.flushall()
def scan_list(name,count=2):
index=0
while True:
data_list=conn.lrange(name,index,count+index-1)
if not data_list:
return
index+=count
for item in data_list:
yield item
print(conn.lrange('test',0,100))
for item in scan_list('test',5):
print('---')
print(item)
Set操作
Set操作，Set集合就是不允許重複的列表
sadd(name,values)
# name對應的集合中新增元素
scard(name)
# 獲取name對應的集合中元素個數
sdiff(keys, *args)
# 在第一個name對應的集合中且不在其他name對應的集合的元素集合
sdiffstore(dest, keys, *args)
# 獲取第一個name對應的集合中且不在其他name對應的集合，再將其新加入到dest對應的集合中
sinter(keys, *args)
# 獲取多一個name對應集合的並集
sinterstore(dest, keys, *args)
# 獲取多一個name對應集合的並集，再講其加入到dest對應的集合中
sismember(name, value)
# 檢查value是否是name對應的集合的成員
smembers(name)
# 獲取name對應的集合的所有成員
smove(src, dst, value)
# 將某個成員從一個集合中移動到另外一個集合
spop(name)
# 從集合的右側（尾部）移除一個成員，並將其返回
srandmember(name, numbers)
# 從name對應的集合中隨機獲取 numbers 個元素
srem(name, values)
# 在name對應的集合中刪除某些值
srem(name, values)
# 在name對應的集合中刪除某些值
sunion(keys, *args)
# 獲取多一個name對應的集合的並集
sunionstore(dest,keys, *args)
# 獲取多一個name對應的集合的並集，並將結果儲存到dest對應的集合中
sscan(name, cursor=0, match=None, count=None)
sscan_iter(name, match=None, count=None)
# 同字串的操作，用於增量迭代分批獲取元素，避免記憶體消耗太大
有序集合
有序集合，在集合的基礎上，為每元素排序；元素的排序需要根據另外一個值來進行比較，所以，對於有序集合，每一個元素有兩個值，即：值和分數，分數專門用來做排序。
zadd(name, *args, **kwargs)
# 在name對應的有序集合中新增元素
# 如：
# zadd('zz', 'n1', 1, 'n2', 2)
# 或
# zadd('zz', n1=11, n2=22)
# zadd('set', {'n1':1, 'n2':2, 'n3':1})
zcard(name)
# 獲取name對應的有序集合元素的數量
zcount(name, min, max)
# 獲取name對應的有序集合中分數 在 [min,max] 之間的個數
zincrby(name, value, amount)
# 自增name對應的有序集合的 name 對應的分數
r.zrange( name, start, end, desc=False, withscores=False, score_cast_func=float)
# 按照索引範圍獲取name對應的有序集合的元素
# 引數：
# name，redis的name
# start，有序集合索引起始位置（非分數）
# end，有序集合索引結束位置（非分數）
# desc，排序規則，預設按照分數從小到大排序
# withscores，是否獲取元素的分數，預設只獲取元素的值
# score_cast_func，對分數進行資料轉換的函式
# 更多：
# 從大到小排序
# zrevrange(name, start, end, withscores=False, score_cast_func=float)
# 按照分數範圍獲取name對應的有序集合的元素
# zrangebyscore(name, min, max, start=None, num=None, withscores=False, score_cast_func=float)
# 從大到小排序
# zrevrangebyscore(name, max, min, start=None, num=None, withscores=False, score_cast_func=float)
zrank(name, value)
# 獲取某個值在 name對應的有序集合中的排行（從 0 開始）
# 更多：
# zrevrank(name, value)，從大到小排序
zrangebylex(name, min, max, start=None, num=None)
# 當有序集合的所有成員都具有相同的分值時，有序集合的元素會根據成員的 值 （lexicographical ordering）來進行排序，而這個命令則可以返回給定的有序集合鍵 key 中， 元素的值介於 min 和 max 之間的成員
# 對集合中的每個成員進行逐個位元組的對比（byte-by-byte compare）， 並按照從低到高的順序， 返回排序後的集合成員。 如果兩個字串有一部分內容是相同的話， 那麼命令會認為較長的字串比較短的字串要大
# 引數：
# name，redis的name
# min，左區間（值）。 + 表示正無限； - 表示負無限； ( 表示開區間； [ 則表示閉區間
# min，右區間（值）
# start，對結果進行分片處理，索引位置
# num，對結果進行分片處理，索引後面的num個元素
# 如：
# ZADD myzset 0 aa 0 ba 0 ca 0 da 0 ea 0 fa 0 ga
# r.zrangebylex('myzset', "-", "[ca") 結果為：['aa', 'ba', 'ca']
# 更多：
# 從大到小排序
# zrevrangebylex(name, max, min, start=None, num=None)
zrem(name, values)
# 刪除name對應的有序集合中值是values的成員
# 如：zrem('zz', ['s1', 's2'])
zremrangebyrank(name, min, max)
# 根據排行範圍刪除
zremrangebyscore(name, min, max)
# 根據分數範圍刪除
zremrangebylex(name, min, max)
# 根據值返回刪除
zscore(name, value)
# 獲取name對應有序集合中 value 對應的分數
zinterstore(dest, keys, aggregate=None)
# 獲取兩個有序集合的交集，如果遇到相同值不同分數，則按照aggregate進行操作
# aggregate的值為: SUM MIN MAX
zunionstore(dest, keys, aggregate=None)
# 獲取兩個有序集合的並集，如果遇到相同值不同分數，則按照aggregate進行操作
# aggregate的值為: SUM MIN MAX
zscan(name, cursor=0, match=None, count=None, score_cast_func=float)
zscan_iter(name, match=None, count=None,score_cast_func=float)
# 同字串相似，相較於字串新增score_cast_func，用來對分數進行操作
其它操作
delete(*names)
根據刪除redis中的任意資料型別
exists(name)
檢測redis的name是否存在
keys(pattern='*')
# 根據模型獲取redis的name
# 更多：
# KEYS * 匹配資料庫中所有 key 。
# KEYS h?llo 匹配 hello ， hallo 和 hxllo 等。
# KEYS h*llo 匹配 hllo 和 heeeeello 等。
# KEYS h[ae]llo 匹配 hello 和 hallo ，但不匹配 hillo
expire(name ,time)
為某個redis的某個name設定超時時間
rename(src, dst)
對redis的name重新命名為
move(name, db))
將redis的某個值移動到指定的db下
randomkey()
隨機獲取一個redis的name（不刪除）
type(name)
獲取name對應值的型別
scan(cursor=0, match=None, count=None)
scan_iter(match=None, count=None)
同字串操作，用於增量迭代獲取key
管道
redis-py預設在執行每次請求都會建立（連線池申請連線）和斷開（歸還連線池）一次連線操作，如果想要在一次請求中指定多個命令，則可以使用pipline實現一次請求指定多個命令，並且預設情況下一次pipline 是原子性操作。
import redis
pool = redis.ConnectionPool(host='10.211.55.4', port=6379)
r = redis.Redis(connection_pool=pool)
# pipe = r.pipeline(transaction=False)
pipe = r.pipeline(transaction=True)
pipe.multi()
pipe.set('name', 'alex')
pipe.set('role', 'sb')
pipe.execute()
Django中使用redis
方式一：
# 新建redis_pool.py
import redis
POOL = redis.ConnectionPool(host='127.0.0.1', port=6379,password='1234',max_connections=1000)
# 檢視函式中使用
import redis
from django.shortcuts import render,HttpResponse
from utils.redis_pool import POOL # 匯入模組,為了實現單例
def index(request):
conn = redis.Redis(connection_pool=POOL)
conn.hset('kkk','age',18)
return HttpResponse('設定成功')
def order(request):
conn = redis.Redis(connection_pool=POOL)
conn.hget('kkk','age')
return HttpResponse('獲取成功')
方式二：
安裝django-redis模組
pip3 install django-redis
# settings.py裡配置
CACHES = {
"default": {
"BACKEND": "django_redis.cache.RedisCache",
"LOCATION": "redis://127.0.0.1:6379",
"OPTIONS": {
"CLIENT_CLASS": "django_redis.client.DefaultClient",
"CONNECTION_POOL_KWARGS": {"max_connections": 100}
# "PASSWORD": "123",
}
}
}
# 檢視函式
from django_redis import get_redis_connection
conn = get_redis_connection('default')
print(conn.hgetall('xxx'))
快取穿透、快取擊穿、快取雪崩區別和解決方案
快取穿透
快取穿透是指快取和資料庫中都沒有的資料，而使用者不斷髮起請求，如發起為id為“-1”的資料或id為特別大不存在的資料。這時的使用者很可能是攻擊者，攻擊會導致資料庫壓力過大。
解決方案：
- 介面層增加校驗，如使用者鑑權校驗，id做基礎校驗，id<=0的直接攔截；
- 從快取取不到的資料，在資料庫中也沒有取到，這時也可以將key-value對寫為key-null，快取有效時間可以設定短點，如30秒（設定太長會導致正常情況也沒法使用）。這樣可以防止攻擊使用者反覆用同一個id暴力攻擊
快取擊穿
快取擊穿是指快取中沒有但資料庫中有的資料（一般是快取時間到期），這時由於併發使用者特別多，同時讀快取沒讀到資料，又同時去資料庫去取資料，引起資料庫壓力瞬間增大，造成過大壓力
解決方案：
- 設定熱點資料永遠不過期。
- 加互斥鎖
快取雪崩
快取雪崩是指快取中資料大批量到過期時間，而查詢資料量巨大，引起資料庫壓力過大甚至down機。和快取擊穿不同的是，快取擊穿指併發查同一條資料，快取雪崩是不同資料都過期了，很多資料都查不到從而查資料庫。
解決方案：
- 快取資料的過期時間設定隨機，防止同一時間大量資料過期現象發生。
- 如果快取資料庫是分散式部署，將熱點資料均勻分佈在不同搞得快取資料庫中。
- 設定熱點資料永遠不過期。