Redis
目录
一、Redis介绍
# Redis ：软件，存储数据的，速度非常快，redis是一个key-value存储系统（没有表的概念），cs架构的软件
-服务端 客户端（python作为客户端，java，go，图形化界面，命令窗口的命令）
# es：存数据的地方
关系型数据库和非关系型数据库
-关系型：mysql，PostgreSQL，oracle，sqlserver，db2
-PG
-去 IOE：国产化
-IBM--->浪潮信息，曙光，联想
-Oracle--->数据---->达梦...
-EMC存储-->国产存储
-非关系型数据库（nosql）：redis（缓存），mongodb（json文档数据存储），es（大数据量存储）...
-nosql 指非关系型数据库： no only sql，对关系型数据库的补充
redis特点
-开源软件，存数据，cs架构
-key-value存储 ，5大数据类型 value的类型是5种：字符串，hash(字典),列表，集合，有序集合
-速度快：
-1 纯内存存储（核心）
-2 使用了IO多路复用的网络模型
-3 数据操作是单线程，避免了线程间切换,而且没有锁，也不会数据错乱
-支持持久化
-纯内存，可以存到硬盘上，防止数据丢失
-redis又被称之为 缓存数据库
二、redis的安装和使用
2.1 安装redis
# redis 是用c语言编写的，需要在不同平台编译成可执行文件，才能在这个平台上运行
-redis 使用了io多路复用种的epoll模型，win不支持epoll
-redis官方，不支持win版本
-微软官方，就把redis改动，编译成可执行，能运行在win上，滞后 3.x版本
-第三方：5.x版本
# redis 官方网：https://redis.io/download/
# redis中文网：http://redis.cn
# win:3.x:https://github.com/microsoftarchive/redis/releases
# win:5.x:https://github.com/tporadowski/redis/releases/
# 安装：一路下一步
-安装完成后，在安装路径下有
-redis-cli.exe # mysql
-redis-server.exe # mysqld
-redis.windows-service.conf # my.ini 配置文件
-并且会自动做成服务
-服务的命令：redis-server.exe redis.windows-service.conf
2.2 启动redis服务端
-1 命令行中 redis 就可以启动服务
-2 命令行中，启动服务，并指定配置文件
redis-server E:\software\redis
redis-server 配置文件路径
-3 使用服务启动
2.3 客户端链接
-方式1 命令行客户端：
-redis-cli # 默认连本地的6379端口
-redis-cli -p 6379 -h 127.0.0.1
-方式2 图形化客户端链接
-1 最新版的Navicate支持链接redis了（收费的）
-2 Redis Desktop Manager（https://resp.app/） 收费的 用的多 qt写图形化界面
-qt是个平台，做GUI[图形化界面]开发
-用c写，用python写 pyqt5
-方式3 python的模块
-pip install redis
2.4 停止redis服务
-客户端链接上后 shutdown，选择SAVE，就会在安装路径下生成一个dump.rdb持久化文件(你停止服务后，就会把内存中的数据保存好，你下次再启动服务，就可以加载，这样数据就不会丢失了)
-在服务中直接点停止
三、redis普通链接和连接池
3.1 普通链接
from redis import Redis
conn = Redis() # 建立redis的链接
res = conn.get('name') # 获取key名为name的value值
print(res) # b'lqz' ,返回的是字节类型
conn.close() # 关闭链接
conn2 = Redis(decode_responses=True) # 添加decode_responses=True，查询回来返回的结果是字符串类型，否则是byte格式
res2 = conn2.get('name')
print(res2) # lqz
conn2.close() # 关闭链接
conn3 = Redis(host="localhost",
port=6379,
db=0,
decode_responses=True,
) # 可以链接外部的ip和端口
res3 = conn3.get('name')
print(res3)
conn3.close()
3.2 连接池链接
# 一定要保证，池是单例的，以模块导入的形式做成了单例
# pool.py
import redis
# 连接池
POOL = redis.ConnectionPool(max_connections=2, host='127.0.0.1', port=6379)
# 其它.py
import redis
from pool import POOL # 模块导入的方式， 天然单例
conn = redis.Redis(connection_pool=POOL) # 以后拿到链接，是从POOL种取，如果没有可用的了，默认不阻塞,可以通过某个参数配置，设置阻塞等待
res = conn.get('name')
print(res)
conn.close()
import redis
from pool import POOL # 模块导入的方式， 天然单例
from threading import Thread
def task():
conn = redis.Redis(connection_pool=POOL)
res = conn.get('name')
print(res)
conn.close()
if __name__ == '__main__':
for i in range(10):
t = Thread(target=task)
t.start()
四、redis字符串类型
redis :https://www.cnblogs.com/liuqingzheng/articles/9833534.html
String操作，redis中的String在在内存中按照一个name对应一个value来存储。如图：
导入
import redis
conn = redis.Redis()
1 set(name, value, ex=None, px=None, nx=False, xx=False)
在Redis中设置值，默认，不存在则创建，存在则修改
参数：
# ex，过期时间（秒）
# px，过期时间（毫秒）
# nx，如果设置为True，则只有name不存在时，当前set操作才执行, 值存在，就修改不了，执行没效果
# xx，如果设置为True，则只有name存在时，当前set操作才执行，值存在才能修改，值不存在，不会设置新值
conn.set('hobby', '足球')
conn.set('hobby1', "['足球', '篮球']")
conn.set('hobby', '篮球', ex=6)
conn.set('hobby', '篮球', px=3000)
conn.set('hobby', '足球', nx=True)
conn.set('hobby', '足球', xx=True)
2 setnx(name, value)
设置值，只有name不存在时，执行设置操作（添加）,如果存在，不会修改
conn.setnx('hobby1', '乒乓球') # 等同于conn.set('hobby', '足球', nx=True)
3 psetex(name, time_ms, value)
设置值
# 参数：
# time_ms，过期时间（数字毫秒 或 timedelta对象）
conn.psetex('name',3000,'xxx')
4 mset(*args, **kwargs)
批量设置值
mget({'k1': 'v1', 'k2': 'v2'})
conn.mset({'name': "lqz", 'height': 183}) # 跟一次次设置的区别是，少了网络交互的时间
5 get(name)
获取值
res = conn.get('hobby') # utf-8 编码，一个中文占3个字节 GBK 编码，一个中文占2个字节
print(res)
6 mget(keys, *args)
批量获取
如：
mget('k1', 'k2')
或
r.mget(['k3', 'k4'])
res = conn.mget('name', 'height')
res = conn.mget(['name', 'height'])
print(res)
7 getset(name, value)
设置新值并获取原来的值
res = conn.getset('name', '彭于晏')
print(res)
8 getrange(key, start, end)
获取子序列（根据字节获取，非字符）
# 参数：
# name，Redis 的 name
# start，起始位置（字节）
# end，结束位置（字节）
# 如： "刘清政" ，0-3表示 "刘"
res = conn.getrange('name', 0, 2) # 前闭后闭区间，拿的是字节，不是字符
print(res)
9 setrange(name, offset, value)
修改字符串内容，从指定字符串索引开始向后替换（新值太长时，则向后添加）
# 参数：
# offset，字符串的索引，字节（一个汉字三个字节）
# value，要设置的值
conn.setrange('name', 3, 'zheng')
10 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"
11 getbit(name, offset)
获取name对应的值的二进制表示中的某位的值 （0或1）
12 bitcount(key, start=None, end=None)
获取name对应的值的二进制表示中 1 的个数
# 参数：
# key，Redis的name
# start，位起始位置
# end，位结束位置
13 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 对应的值中
14 strlen(name)
返回name对应值的字节长度（一个汉字3个字节）
res = conn.strlen('name') # 9 统计字节长度
print(res)
15 incr(self, name, amount=1)
# 自增 name对应的值，当name不存在时，则创建name＝amount，否则，则自增。同incrby
# 参数：
# name,Redis的name
# amount,自增数（必须是整数）
# 做计数器。不会出现并非安全问题
conn.incrby('height')
conn.incrby('height', 9)
16 incrbyfloat(self, name, amount=1.0)
自增 name对应的值，当name不存在时，则创建name＝amount，否则，则自增。
# 参数：
# name,Redis的name
# amount,自增数（浮点型）
conn.incrbyfloat('height', 0.9) # 195.90000000000000568
17 decrby(self, name, amount=1)
自减 name对应的值，当name不存在时，则创建name＝amount，否则，则自减。同incr
# 参数：
# name,Redis的name
# amount,自减数（整数）
conn.decrby('height', 5)
18 append(key, value)
在redis name对应的值后面追加内容
# 参数：
key, redis的name
value, 要追加的字符串
conn.append('name', 'xxxx')
conn.close()
重点
'''
get
set
strlen
append
'''
五、redis hash类型
Hash操作，redis中Hash在内存中的存储格式如下图：
# hash类型就是咱们python中的字典，key-value,字典又叫hash类型 字典的key必须可hash
-字典类型在底层存储，基于数组存的
key---{key:value,key:value}
链接
import redis
conn = redis.Redis(decode_responses=True)
1 hset(name, key, value)
# name对应的hash中设置一个键值对（不存在，则创建；否则，修改）
# 参数：
# name，redis的name
# key，name对应的hash中的key
# value，name对应的hash中的value
# 注：
# hsetnx(name, key, value),当name对应的hash中不存在当前key时则创建（相当于添加）
conn.hset('userinfo', 'name', '刘亦菲')
conn.hset('userinfo', 'age', '38')
2 hmset(name, mapping)
# 弃用了，还能用
conn.hmset('userinfo2', {'name': '哈哈哈', 'height': 166})
conn.hset('userinfo3', mapping={'name': '彭于晏123', 'height': 183})
3 hget(name,key)
# 在name对应的hash中获取根据key获取value
res = conn.hget('userinfo', 'age')
res = conn.hget('userinfo', 'height') # 没有数据返回None
print(res)
4 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')
res = conn.hmget('userinfo', ['name', 'age'])
print(res)
5 hgetall(name)
# 获取name对应hash的所有键值
# 慎用，如果hash中key非常的，可能会撑爆内存
res = conn.hgetall('userinfo')
print(res) # {'name': '刘亦菲', 'age': '38'}
6 hlen(name)
# 获取name对应的hash中键值对的个数
res = conn.hlen('userinfo')
print(res)
7 hkeys(name)
# 获取name对应的hash中所有的key的值
print(conn.hkeys('userinfo'))
8 hvals(name)
# 获取name对应的hash中所有的value的值
print(conn.hvals('userinfo'))
9 hexists(name, key)
# 检查name对应的hash是否存在当前传入的key
print(conn.hexists('userinfo', 'name'))
print(conn.hexists('userinfo', 'height'))
10 hdel(name,*keys)
# 将name对应的hash中指定key的键值对删除
conn.hdel('userinfo2', 'name', 'height')
11 hincrby(name, key, amount=1)
# 自增name对应的hash中的指定key的值，不存在则创建key=amount
# 参数：
# name，redis中的name
# key， hash对应的key
# amount，自增数（整数）
conn.hincrby('userinfo3', 'height')
conn.hincrby('userinfo3', 'height', 8)
12 hincrbyfloat(name, key, amount=1.0)
# 自增name对应的hash中的指定key的值，不存在则创建key=amount
# 参数：
# name，redis中的name
# key， hash对应的key
# amount，自增数（浮点数）
# 自增name对应的hash中的指定key的值，不存在则创建key=amount
conn.hincrbyfloat('userinfo3', 'height', 0.1)
他们是一家(13、14)
13 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时，表示数据已经通过分片获取完毕
14 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
获取所有数据的不同方法
数据准备
for i in range(1000):
conn.hset('hash_test', 'egg_%s' % i, '鸡蛋%s号' % i)
# 方式一
# res = conn.hgetall('hash_test')
# print(res)
# 方式二
# res = conn.hscan('hash_test', cursor=0, count=20)
# print(res) # 元组(数字，字典(20个))
# print(res[1]) # 字典组成20个数据
# print(len(res[1])) # 20
# 方式三
# res = conn.hscan_iter('hash_test', count=10) # 取出所有，每次拿10条,用完再取10条，直到取完，内部使用了hscan+生成器，占内存小，区分与hgetall
# print(res) # <generator object ScanCommands.hscan_iter at 0x0000014B4DF0BAC0>
#
# for item in res:
# print(item)
conn.close()
重点
'''
hset
hget
hlen
hexisit
'''
补充：字符串和字节转换
# 区分字符和字节
'''
字符： 'a' '你' '😊' 需要更长的字节来存储---> gbk，utf-8编码---> 一个字符占多少字节取决于编码格式
字节： 8个比特位是一个字节 ，一个字节能存一个字符吗？ 只能存 ascii 的字符
A: 65
a: 97
0: 48
'''
# 字符串
s='乒乓球'
print(s)
print(len(s)) # 字符长度
# 字符串转成bytes格式，转成字节格式
b=s.encode('utf-8')
print(b) # \xe4\xb9\x92\xe4\xb9\x93\xe7\x90\x83 16进制表示
print(len(b))
l1=[hex(i) for i in b] # 十六进制
l2=[bin(i) for i in b] # 二进制
l3=[i for i in b] # 十进制
print(l1)
print(l2)
print(l3)
# bytes转成字符串
print(b.decode('utf-8'))
# 字符串需要用encode，bytes格式需要用decode，但是有时候忘了，直接做类型转换就行
b1=bytes(s,encoding='utf-8')
print(b1)
print(str(b1,encoding='utf-8'))
六、redis列表操作
List操作，redis中的List在在内存中按照一个name对应一个List来存储。如图：
1 lpush(name,values)
# 在name对应的list中添加元素，每个新的元素都添加到列表的最左边
# 如：
# r.lpush('oo', 11,22,33)
# 保存顺序为: 33,22,11
conn.lpush('hobbys', '篮球')
conn.lpush('hobbys', '足球')
conn.lpush('hobbys', '乒乓球')
conn.lpush('eggs', '加单1好', '鸡蛋2好', '鸡蛋3号')
2 rpush(name, values)
表示从右向左操作
conn.rpush('hobbys', '橄榄球')
3 lpushx(name,value)
# 在name对应的list中添加元素，只有name已经存在时，值添加到列表的最左边
# 更多：
# rpushx(name, value) 表示从右向左操作
conn.lpushx('hobbys1', '排球')
conn.lpushx('hobbys', '排球')
conn.rpushx('hobbys', '网球')
4 llen(name)
# name对应的list元素的个数
print(conn.llen('hobbys'))
5 linsert(name, where, refvalue, value))
# 在name对应的列表的某一个值前或后插入一个新值
# 参数：
# name，redis的name
# where，BEFORE或AFTER(小写也可以)
# refvalue，标杆值，即：在它前后插入数据（如果存在多个标杆值，以找到的第一个为准）
# value，要插入的数据
conn.linsert('hobbys', 'after', '乒乓球', '保龄球')
conn.linsert('hobbys', 'before', '篮球', '曲球')
6 r.lset(name, index, value)
# 对name对应的list中的某一个索引位置重新赋值
# 参数：
# name，redis的name
# index，list的索引位置
# value，要设置的值
conn.lset('hobbys', 2, '足球')
7 r.lrem(name, num, value)
# 在name对应的list中删除指定的值
# 参数：
# name，redis的name
# value，要删除的值
# num， num=0，删除列表中所有的指定值；
# num=2,从前到后，删除2个；
# num=-2,从后向前，删除2个
conn.lrem('hobbys', 0, '足球') # 0 表示全删除
conn.lrem('hobbys', 2, '足球') # 正数表示从左侧删除，数量表示删除几个
conn.lrem('hobbys', -1, '球球球') # 负数表示从右侧删除1个
8 lpop(name)
# 在name对应的列表的左侧获取第一个元素并在列表中移除，返回值则是第一个元素
# 更多：
# rpop(name) 表示从右向左操作
print(conn.lpop('hobbys'))
print(conn.lpop('hobbys'))
9 lindex(name, index)
在name对应的列表中根据索引获取列表元素
res = conn.lindex('hobbys', 4)
print(res)
10 lrange(name, start, end)
# 在name对应的列表分片获取数据
# 参数：
# name，redis的name
# start，索引的起始位置，前闭后闭区间
# end，索引结束位置
print(conn.lrange('hobbys', 0, 2))
print(conn.lrange('hobbys', 0, conn.llen('hobbys'))) # 获取列表全部元素
11 ltrim(name, start, end)
# 在name对应的列表中移除没有在start-end索引之间的值
# 参数：
# name，redis的name
# start，索引的起始位置
# end，索引结束位置（大于列表长度，则代表不移除任何）
print(conn.ltrim('hobbys', 6, 9)) # True
12 rpoplpush(src, dst)
# 从一个列表取出最右边的元素，同时将其添加至另一个列表的最左边
# 参数：
# src，要取数据的列表的name
# dst，要添加数据的列表的name
conn.rpoplpush('hobbys', 'hobbys') # 把同一个列表的右边的元素添加到左边
conn.rpoplpush('hobbys', 'eggs') # 把hobbys的右边的元素添加到eggs的左边
13 blpop(keys, timeout)
# 将多个列表排列，按照从左到右去pop对应列表的元素
# 参数：
# keys，redis的name的集合
# timeout，超时时间，当元素所有列表的元素获取完之后，阻塞等待列表内有数据的时间（秒）, 0 表示永远阻塞
# 更多：
# r.brpop(keys, timeout)，从右向左获取数据
爬虫实现简单分布式：多个url放到列表里，往里不停放URL，程序循环取值，但是只能一台机器运行取值，可以把url放到redis中，多台机器从redis中取值，爬取数据，实现简单分布式
这个就是简单的消息队列，可以实现分布式的程序---->生产者消费者模型
res = conn.blpop('eggs', timeout=1) # 如果1秒还没有值，就输出None
print(res)
14 brpoplpush(src, dst, timeout=0)
# 从一个列表的右侧移除一个元素并将其添加到另一个列表的左侧
# 参数：
# src，取出并要移除元素的列表对应的name
# dst，要插入元素的列表对应的name
# timeout，当src对应的列表中没有数据时，阻塞等待其有数据的超时时间（秒），0 表示永远阻塞
15 自定义增量迭代
# 由于redis类库中没有提供对列表元素的增量迭代，如果想要循环name对应的列表的所有元素，那么就需要：
# 1、获取name对应的所有列表
# 2、循环列表
# 创造数据
for i in range(1000):
conn.lpush('eggs', '鸡蛋%s号' % i)
# 一次性把列表中所有数据取出来
# 方式一：使用lrange，索引结束写个特别大的数字
# res = conn.lrange('eggs', 0, 10000)
# print(res)
'''缺点：不知道列表的实际长度是多少，有可能会写到比列表实际长度小'''
# 方式二：使用lrange，索引结束写列表长度
# l = conn.llen('eggs')
# res = conn.lrange('eggs', 0, l)
# print(res)
'''缺点：取出redis的eggs的数据，但是万一数据量比较大，会溢出内存'''
# 方式三：使用生成器，取出固定数量的元素
def l_scan_iter(key, count=10):
num = 0
while True:
print('--------')
res = conn.lrange(key, num, num + count - 1)
num += count
if res:
for item in res:
yield item
# yield res # 组成列表，10个值一个列表
else:
break
for i in l_scan_iter('eggs'):
print(i)
# 补充：生成器
def index():
yield 1
yield 2
yield 3
for i in index():
print(i)
'''
1
2
3
'''
重点
lpush
lpop
linsert
lset
llen
lrange
七 其他操作
1 delete(*names)
# 根据删除redis中的任意数据类型
conn.delete('name', 'hobby')
2 exists(name)
# 检测redis的name是否存在
print(conn.exists('userinfo')) #db0中如果有这个key，输出1。没有，输出0
3 keys(pattern='*')
# 根据模型获取redis的name
# 更多：
# KEYS * 匹配数据库中所有 key 。
# KEYS h?llo 匹配 hello ， hallo 和 hxllo 等。
# KEYS h*llo 匹配 hllo 和 heeeeello 等。
# KEYS h[ae]llo 匹配 hello 和 hallo ，但不匹配 hillo
res = conn.keys('*')
res = conn.keys('n*')
res = conn.keys('nam?')
print(res)
4 expire(name ,time)
# 为某个redis的某个name设置超时时间
conn.expire('height', 5)
5 rename(src, dst)
# 对redis的name重命名为
conn.rename('name', 'name1')
6 move(name, db))
# 将redis的某个值移动到指定的db下
conn.move('name1', 2)
7 randomkey()
# 随机获取一个redis的name（不删除）
res = conn.randomkey()
print(res)
8 type(name)
# 获取name对应值的类型
res = conn.type('userinfo') # name存在输出name对应值的类型，name不存在输出none
print(res)
八、redis管道
# 事务四大特性
-原子性：要么都成功，要么都失败
-一致性：数据前后要一致
-隔离性：多个事务之间相互不影响
-持久性：事务一旦完成，数据永久改变
# redis 有没有事务？支持事务
-redis要支持事务，要完成事务的几大特性，需要使用管道来支持
-单实例redis是支持管道的
-集群模式下，不支持管道，就不支持事务
8.1 操作
import redis
conn = redis.Redis()
# 第一步：实现a1给b2转10元
# conn.decrby('a1', 10)
# conn.incrby('b2', 10)
# 第二步：如果中间出现问题，a1减少了，但是b2没有增加
# conn.decrby('a1', 10)
# raise Exception('出错了')
# conn.incrby('b2', 10)
# 第三步：redis通过管道实现事务
pipeline = conn.pipeline(transaction=True)
pipeline.decrby('a1', 10) # 没有真正执行，把命令先放到管道中
raise Exception('出错了')
pipeline.incrby('b2', 10)
pipeline.execute() # 把管道中的命令，一次性执行
conn.close()
8.2 django中使用redis
redis的简单使用
import redis
class MyResponseView(APIView):
def get(self, request):
# 访问一次，redis的a1 +1
conn = redis.Redis()
conn.incrby('a1') # 没有池的方案，来几个请求，就会创建几个链接
return APIResponse()
使用池
# 自定义的通用方案（跟框架无关）
-写一个py文件：redis_pool.py
import redis
POOL = redis.ConnectionPool(max_connections=2)
-在用的位置，导入直接使用
from utils.redis_pool import POOL
class MyResponseView(APIView):
def get(self, request):
conn = redis.Redis(connection_pool=POOL)
conn.incrby('a1')
return APIResponse()
8.4 第三方模块
- django中有个模块，django-redis，方便我们快速集成redis
下载
pip install django-redis
settings/dev.py
# redis的配置
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
class MyResponseView(APIView):
def get(self, request):
conn = get_redis_connection() # 从连接池中拿出一个链接
conn.incrby('a1')
conn.set('name1', '彭于晏')
return APIResponse()
8.5 django缓存
# django 是大而全的框架，内置了很多web开发需要的东西，缓存内置了
# 缓存：可以把django中的一个变量(数据)，存放到某个位置，下次还可以取出来
# 之前用过：默认放在：内存中，其实可以放在文件中，数据库，redis...
from django.core.cache import cache
cache.set('key','value',5) # 存放值
res=cache.get('key') # 取值
# 通过配置，控制存放在哪，只要如下写，就会放在redis中
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",
}
}
}
# django缓存最强大之处在于，只要是python的变量，任意类型都可以，尽管使用set设置值
l = [1, 'lqz', [1, 3, 4, 5, 6], '彭于晏']
cache.set('ll1', l)
# 以后再django中往redis放数据，就用cache即可
# redis的5大数据类型，只支持一层
# 看一下这篇文章：https://www.cnblogs.com/liuqingzheng/articles/9803351.html
测试缓存的使用
from django.core.cache import cache
class MyResponseView(APIView):
def get(self, request):
# cache.set('age1', 10) # 现在放在redis中
# conn = get_redis_connection()
# conn.lpush('l1', [1, 2, 3])
# # 这样存放会报错，需要存放json格式字符串。要做序列化
# 用catch就可以存放python的所有格式数据
# l = [1, 'lqz', [1, 3, 4, 5, 6], '彭于晏']
# cache.set('ll1', l)
# 获取数据
print(cache.get('ll1'))
return APIResponse()
补充
#序列化
-json序列化--->得到字符串
json不能序列化对象(自定义的类的对象)
-数据结构：数据的组织形式跟下面不一样
能序列化： 数字，字符串，布尔，列表，字典 时间对象
-pickle序列化
-python独有的，二进制形式
-python可以序列化所有对象--->二进制形式
-二进制--->返序列化回来--->对象：属性，有方法
