redis
什么是Redis
Redis(Remote Dictionary Server) 是一个使用 C 语言编写的，开源的(BSD许可)高性能非关系型(NoSQL)的键值对数据库。
Redis 可以存储键和五种不同类型的值之间的映射。键的类型只能为字符串，值支持五种数据类型：字符串、列表、集合、散列表、有序集合。
与传统数据库不同的是 Redis 的数据是存在内存中的，所以读写速度非常快，因此 redis 被广泛应用于缓存方向，每秒可以处理超过 10万次读写操作，是已知性能最快的Key-Value DB。另外，Redis 也经常用来做分布式锁。除此之外，Redis 支持事务 、持久化、LUA脚本、LRU驱动事件、多种集群方案。
redis的好处
- 速度快，应为数据存在内存中，类似于字典，字典的优势就是查找和操作时间的复杂度都是0(1)
- 支付丰富的数据类型：支持string，list，set，sorted set，hash
- 支持事务，操作都是原子性，所谓的原子性就是对数据的更改要么全部执行，要么全部不执行
- 丰富的特性：可用于缓存，消息，按key设置过期时间，过期后将会自动删除
redis 最适合的场景
主要做缓存，有称之为缓存数据库。
- 会话缓存(Session Cache)，存储session，之前存储在MySQL，存在Redis中速度快
- 接口，页面缓存，将数据接口存储在redis中。
- 队列--->celery使用
- 排行榜/计数器--->个人页面访问量
- 发布/订阅
安装redis
Redis 是C语言写的开元软件，官方提供了源码，如果在mac或linux上需要编译安装。
redis最新稳定版版本6.x
win：
作者不支持windwos，本质原因：redis很快，使用了io多路复用中的epoll的网络模型，这个模型不支持win，所以不支持(看到高性能的服务器基本上都是基于io多路复用中的epoll的网络模型，nginx)，微软基于redis源码，自己做了个redis安装包，但是这个安装包最新只到3.x，又有第三方组织做到最新5.x的安装包
Mac :
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"可能遇到的问题，没有安装wget：
xiejunjie@junjiedeMacBook-Pro ~ wget http://download.redis.io/releases/redis-3.0.6.tar.gz
zsh: command not found: wget以下为安装wget:
从ftp://ftp.gnu.org/gnu/wget/下载到最新的wget安装包到本地
我安装的是1.8版本，拉到你创建的文件夹，解压。
依次执行：
./configure
make
make install
或者如果安装了 oh my zsh 则需要修改.zshrc，因为.bash_profile中配置的环境变量需要在.zshrc中设置，找到这里加入框框中的命令即可。
安装成功之后安装redis可视化软件rbm(Redis Desktop Manager)
破解版链接:https://www.macwk.com/soft/redis-desktop-manager
python链接Redis
安装模块
pip install redis导入模块
from redis import Redis右键点击Redis发现是一个类，类就需要实例化得到对象，类在实例化的时候会触发__init__
conn = Redis(host="localhost", # 本地
port=6379, # 端口
db=0, # 代表链接第0个数据库
password=None, )普通链接
此时证明已经链接到redis。
上面介绍中说过，Redis是已知性能最快的Key-Value DB，所以设置就是字典的形式。
连接池链接
链接池的概念：
假设我们的服务是通过链接链接池再链接到Redis服务，假设链接池设置三个链接，这三个链接和Redis服务连接，那么服务端不管起了多少个线程，都只能先经过这三个链接才能连接到Redis服务，这样就不会对Redis服务造成瞬间并发量过高的影响。
Django中有没有连接池。
没有，Django中一个请求就会创建一个mysql连接，假设现在同时有十个人访问数据库，那么就会有是个连接来操作MySQL，但是django并发量不高，mysql能撑住
想在django中使用连接池，有第三方：
https://www.cnblogs.com/wangruixing/p/13030755.html
还有需要注意的一点，创建连接池的代码只能执行一次，即为单例模式，如果连接池代码可以运行多次的情况下，就会发生程序-->连接池-->redis一直重复的发生。
先将连接池链接代码记录。
import redis
from redis import Redis
# 构造一个池
POOL = redis.ConnectionPool(max_connections=10, # 连接池大小
host="localhost",
port=6379,)
# 从池中拿一个连接
conn = redis.Redis(connection_pool=POOL)
print(conn.get('name'))
那什么为单例模式？
单例模式(Singleton Pattern)是一种常用的软件设计模式，该模式的主要目的是确保某一个类只有一个实例存在。当你希望在整个系统中，某个类只能出现一个实例时，单例对象就能派上用场。
通俗一点理解就是,以下这段代码中的POOL这个对象，无论程序怎么运行，都只能是同一个对象：
import redis
from redis import Redis
# 构造一个池
POOL = redis.ConnectionPool(max_connections=10, # 连接池大小
host="localhost",
port=6379,)
# 从池中拿一个连接
conn = redis.Redis(connection_pool=POOL)
print(conn.get('name'))实现单例模式有五种方式，晚点单开一个博客。
实现单例，我们这里就使用导入模块的方式。
Python 的模块就是天然的单例模式，因为模块在第一次导入时，会生成 .pyc 文件，当第二次导入时，就会直接加载 .pyc 文件，而不会再次执行模块代码。因此，我们只需把相关的函数和数据定义在一个模块中，就可以获得一个单例对象了。
在此文件的同一路径下创建一个py文件,写入代码。
redis_pool.py
import redis
# 构造一个池
POOL = redis.ConnectionPool(max_connections=10, # 连接池大小
host="localhost",
port=6379,)redis_pool.py
import redis
# 以模块导入的方式实现单例
from redis_pool import POOL
conn = redis.Redis(connection_pool=POOL)
print(conn.get('name'))
redis字符串操作
String操作，redis中的String在在内存中按照一个name对应一个value来存储。如图：
set(name, value, ex=None, px=None, nx=False, xx=False)
在Redis中设置值，默认，不存在则创建，存在则修改
参数：
ex，过期时间(秒)
px，过期时间(毫秒)
nx，如果设置为True，则只有name不存在时，当前set操作才执行,值存在，就修改不了，执行没效果
xx，如果设置为True，则只有name存在时，当前set操作才执行，值存在才能修改，值不存在，不会设置新值nx
此事想把lyf修改成dlrb，但是nx=True,不能执行
xx
此事想把lyf修改成dlrb，但是xx=True,能执行
setex(name, value, time)等同于conn.set('wife','lyf',ex=3)
# 设置值
# 参数：
# time，过期时间(数字秒 或 timedelta对象)psetex(name, time_ms, value)等同于conn.set('wife','lyf',px=3)
# 设置值
# 参数：
# time_ms，过期时间(数字毫秒 或 timedelta对象mset(*args, **kwargs)
批量设置值
如：
mset(k1='v1', k2='v2')
或
mget({'k1': 'v1', 'k2': 'v2'})
get(name)
获取值
print(conn.get('name1'))
mget(keys, *args)
批量获取
如：
mget('k1', 'k2')
或
r.mget(['k3', 'k4'])
print(conn.mget('name','name1','age1','age'))
输出: [b'junjie', b'junjie', b'18', None]getset(name, value)
设置新值并获取原来的值
print(conn.getset('name','dsb'))
输出:b'junjie'getrange(key, start, end)
# 获取子序列(根据字节获取，非字符)
# 参数：
# name，Redis 的 name
# start，起始位置(字节)
# end，结束位置(字节)
print(conn.getrange('name',0,0))
print(conn.getrange('name',0,1))
上面设置{'name':'dsb'}
输出：
b'd'
b'ds'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，位结束位置示例：
# 数字指的是字节，一个字节对应8个比特位
print(conn.bitcount('name',0,1))
输出：
8bitop(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没有name会自动创建name,并自增1
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, 要追加的字符串redis之hash操作
Hash操作，redis中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时则创建(相当于添加)示例：
conn.hset('hash1','lyf','junjie')
也可以再次设置name:
hmset(name, mapping)
# 在name对应的hash中批量设置键值对
# 参数：
# name，redis的name
# mapping，字典，如：{'k1':'v1', 'k2': 'v2'}
# 如：
# r.hmset('xx', {'k1':'v1', 'k2': 'v2'})示例：
conn.hmset('userinfo_1',mapping={'name':'junjie','age':18})hget(name,key)
# 在name对应的hash中获取根据key获取value示例：
print(conn.hget('userinfo', 'name'))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')示例：
print(conn.hmget('userinfo_1', ['name','like','age']))
输出：
[b'junjie', b'\xe5\x88\x98\xe4\xba\xa6\xe8\x8f\xb2', b'18']
中文为二进制格式，一个汉字为三个字节print(str(conn.hget('userinfo_1','like'),encoding='utf8'))
输出：
刘亦菲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举例：
print(conn.hexists('userinfo','name'))
输出：
布尔值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=amounthscan(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时，表示数据已经通过分片获取完毕举例：
hash类型是无序的。
先创建数据
import redis
conn = redis.Redis()
for i in range(1000):
conn.hset('hash_test',f'id{i}',f'鸡蛋{i}号')
import redis
conn = redis.Redis()
# 分批获取，但是由于没有顺序，会返回一个cursor，下次基于这个cursor再继续获取
res = conn.hscan('hash_test',0,count=10)
print(res) # 会返回一个游标
res1 = conn.hscan('hash_test',960,count=10)
print(res1)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举例：
import redis
conn = redis.Redis()
# 全取出所有值，分批取，不是一次性全取回来，减小内存占用
res = conn.hscan_iter('hash_test',count=10)
print(res)
for i in res:
print(res)常用：
hset hget hlen hexistsRedis 列表操作
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, value, num)
# 在name对应的list中删除指定的值
# 参数：
# name，redis的name
# value，要删除的值
# num， num=0，删除列表中所有的指定值；
# num=2,从前到后，删除2个；
# num=-2,从后向前，删除2个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，要添加数据的列表的nameblpop(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 表示永远阻塞常用：
lupsh lpop linsert llen blpop通用操作：
delete(*names)
# 根据删除redis中的任意数据类型exists(name)
# 检测redis的name是否存在，返回0/1keys(pattern='*')
# 根据模型获取redis的name
# 更多：
# KEYS * 匹配数据库中所有 key 。
# KEYS h?llo 匹配 hello ， hallo 和 hxllo 等。
# KEYS h*llo 匹配 hllo 和 heeeeello 等。
# KEYS h[ae]llo 匹配 hello 和 hallo ，但不匹配 hilloexpire(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 是原子性操作。
redis本身是不支持事务的，有时候我们需要实现类似这种功能：张三-100块钱，李四+100块钱。
那么，可以通过管道实现，将多次操作的命令放到一个管道中，一次执行，要么都执行，要么都不执行。
举例：
import redis
pool = redis.ConnectionPool()
conn = redis.Redis( connection_pool=pool)
pipe = conn.pipeline(transaction=True)
# 之后用pipe代替conn
pipe.multi()
# 以下两步只是向管道中存放命令，还没有执行
pipe.set('name','junjie')
# 假设此时抛出异常，终端了代码的执行，那么pipe的set便都不会执行
raise Exception('主动抛出异常，阻塞代码运行')
pipe.set('age',18)
# 此时执行
pipe.execute()
但是，此时去除主动抛出异常，就可以完成事务。
import redis
pool = redis.ConnectionPool()
conn = redis.Redis( connection_pool=pool)
pipe = conn.pipeline(transaction=True)
# 之后用pipe代替conn
pipe.multi()
# 以下两步只是向管道中存放命令，还没有执行
pipe.set('name','junjie')
pipe.set('age',18)
# 此时执行
pipe.execute()
Django中使用redis
方式一：自己写
创建pool.py
import redis
# 创建链接池，用作全局单例
POOL=redis.ConnectionPool(max_connections=10,host="localhost",port=6379)任意位置
# 任意位置使用
from utils.pool import POOL
import redis
class TestView(APIView):
def get(self, requeste):
# 重点这一句
conn=redis.Redis(connection_pool=POOL)
print(conn.get('name'))
return Response('ok')方式二：使用第三方 django-redis
下载模块：
pip install djagno-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} # 链接池为100
# "PASSWORD": "123",
}
}
}使用需要导入模块
from django_redis import get_redis_connection在需要使用位置：
conn=get_redis_connection()
print(conn.get('name'))并且，一旦如此配置之后，Django使用的缓存就是Redis
假设在GET请求中加入代码。
from django.shortcuts import render
# Create your views here.
import redis
from .models import User
from django.core.cache import cache
from utils.response import APIResponse
from utils.pool import POOL
from rest_framework.viewsets import ViewSet
from rest_framework.decorators import action
from rest_framework.exceptions import APIException
from django_redis import get_redis_connection
class UserAPIView(ViewSet):
# 客户端发送GET请求，携带手机号，此时能校验手机号
"""
methods:声明该action对应的请求方式，列表传递
detail: 声明该action路径是否为单一资源对应(False查询所有数据接口，True查询单条数据接口)
"""
@action(methods=["GET"], detail=False)
def check_mobile(self, request):
try:
# conn = get_redis_connection()
# # b'junjie'
# print(conn.get('name'))
# 使用drf继承了APIView时，需要取get提交数据，要从query_param中取
# cache.set('name','junjie')
print(cache.get('name'))
mobile = request.query_params.get('mobile')
# 客户端的GET请求中携带?mobile=15058066669,15058066669
# print(mobile)
# 检验手机号是否存在
User.objects.get(mobile=mobile)
# junjie
# print(a)
"""
如果能查到，返回自定义的APIResponse，返回的内容是{'status':status,'msg':msg}
前端校验只要是100手机号就是存在，反之不在。
"""
return APIResponse()
except Exception as e:
raise APIException(str(e))设置缓存
作用：
以后在Django中，不用使用Redis拿链接操作，直接用cache做就可以。并且不用再关注设置的值类型是什么，cache.set('name',['junjie','lyf]),列表，字典任何数据类型，对象也可以。
底层原理是将value通过pickle转成了二进制，以redis字符串的形式存到了redis中。
pickle是python独有的序列化和反序列化，只能python玩，把python中所有数据类型都能转成二进制
通过二进制可以在反序列化成功pyhton中的任意对象
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
