#1 key-value的存储方式，value有很多数据类型：5大：string(字符串)、list(链表)、set(集合)、zset(sorted set --有序集合)和hash（哈希类型
#2 内存数据库
#3 与Memcached比较：
    -1 Memcached只支持一种数据类型字符串
    -2 Memcached不支持持久化（不支持存到硬盘上，只要一断电，数据就没了）
    
# 4 使用Redis有哪些好处？
(1) 速度快，因为数据存在内存中，类似于HashMap，HashMap的优势就是查找和操作的时间复杂度都是O(1)
(2) 支持丰富数据类型，支持string，list，set，sorted set，hash
(3) 支持事务，操作都是原子性，所谓的原子性就是对数据的更改要么全部执行，要么全部不执行
(4) 丰富的特性：可用于缓存，消息，按key设置过期时间，过期后将会自动删除
# 5 单线程，单进程，不存在并发访问的问题（新版本已经不是了）
    -单线程为什么这么快
        -数据在内存（最重要的）
        -io多路复用技术
        -因为没有进程，线程间的切换
# 6 redis适合的场景
    1 排行榜
    2 网站访问量，文章访问量
    3 缓存数据库（用的最多，就是做缓存）
    4 发布订阅
    5 去重
    6 分布式（blpop）
    
# 7 安装
    -Redis-x64-3.2.100.msi  安装包
    -redis-desktop-manager-0.9.3.817.exe 等同于navicate
    
    
# 8 使用
    -服务端和客户端
    -安装完，服务端自动启动：redis-server 配置文件.conf
    -redis-cli  ：客户端连接服务端(redis-cli -h 127.0.0.1 -p 6379)

可以持久化
单线程，单进程

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"

"""
前提：前往一个方便管理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
"""

"""
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服务的当前路径
"""

"""
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 密码
"""

"""
数据操作：字符串、列表、哈希(字典)、无序集合、有序(排序)集合
    有序集合：游戏排行榜
    
字符串：
    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
"""

# pip install redis

from redis import Redis
# conn=Redis()
#连接对象
conn=Redis(host='127.0.0.1', port=6379)
ret=conn.get('name')
print(ret)

#redis连接池
import redis
#pool必须是单例的
pool = redis.ConnectionPool(host='127.0.0.1', port=6379,max_connections=100)  # 造一个池子,最多能放100个连接

conn = redis.Redis(connection_pool=pool)  # 只要执行这一句话，就是从池中拿出一个连接
ret=conn.get('foo')
print(ret)

import redis

# pool必须是单例的
POOL = redis.ConnectionPool(host='127.0.0.1', port=6379, max_connections=100, decode_responses=True)  # 造一个池子,最多放100个连接

###### t_redis_pool.py
import redis
# pool必须是单例的
POOL = redis.ConnectionPool(host='127.0.0.1', port=6379, max_connections=100)   # 造一个池子,最多放100个连接

#######t_redis_conn.py
import redis
#包内的py文件，如果想右键运行，导包的时候不能带点
from t_redis_pool import POOL  # pycharm提示的错
conn = redis.Redis(connection_pool=POOL)  # 只要执行这一句话，就是从池中拿出一个连接
ret=conn.get('foo')
print(ret)

import redis

# 连接对象
# conn = redis.Redis.from_url("redis://[[username]:[password]]@localhost:6379/0")
conn = redis.Redis.from_url("redis://localhost:6379/0",decode_responses=True)

ret=conn.get('foo')
print(ret)

# 在Redis中设置值，默认，不存在则创建，存在则修改
# 参数：
     ex，过期时间（秒）
     px，过期时间（毫秒）
     nx，如果设置为True，则只有name不存在时，当前set操作才执行,值存在，就修改不了，执行没效果
     xx，如果设置为True，则只有name存在时，当前set操作才执行，值存在才能修改，值不存在，不会设置新值

# 设置值，只有name不存在时，执行设置操作（添加）,如果存在，不会修改

# 设置值
# 参数：
    # time，过期时间（数字秒 或 timedelta对象）

# 设置值
# 参数：
    # time_ms，过期时间（数字毫秒 或 timedelta对象

# 批量设置值
# 如：
    mset(k1='v1', k2='v2')
    或
    mget({'k1': 'v1', 'k2': 'v2'})

# 获取值，默认获取值是bytes格式，可以在创建连接对象的时候，添加一个decode_responses=True参数，之后获取到值之后就是想要的格式
import redis

# 连接对象
conn = redis.Redis(host='127.0.0.1', port=6379, decode_responses=True)
conn.set('foo', 'Bar')
print(conn.get('foo'))

# 批量获取
# 如：
    mget('k1', 'k2')
    或
    r.mget(['k3', 'k4'])

# 设置新值并获取原来的值

# 获取子序列（根据字节获取，非字符）
# 参数：
    # name，Redis 的 name
    # start，起始位置（字节）
    # end，结束位置（字节）
# 如： "刘清政" ，0-0表示 "刘"，因为中文字符占3个字节
import redis

# 连接对象
conn = redis.Redis(host='127.0.0.1', port=6379, decode_responses=True)
conn.set('foo', 'Bar')
print(conn.getrange("foo", 0, 0))    # B

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

# 示例：
import redis

# 连接对象
conn = redis.Redis(host='127.0.0.1', port=6379, decode_responses=True)
print(conn.get('foo'))   # Bar
conn.setrange('foo', 1, "oos")
print(conn.get('foo'))   # Boos

# 对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"

# 获取name对应的值的二进制表示中的某位的值 （0或1）

# 获取name对应的值的二进制表示中 1 的个数
# 参数：
    # key，Redis的name
    # start，位起始位置
    # end，位结束位置

# 获取多个值，并将值做位运算，将最后的结果保存至新的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 对应的值中

# 返回name对应值的字节长度（一个汉字3个字节）

# 自增 name对应的值，当name不存在时，则创建name＝amount，否则，则自增。
 
# 参数：
    # name,Redis的name
    # amount,自增数（必须是整数）

# 示例
import redis

# 连接对象
conn = redis.Redis(host='127.0.0.1', port=6379, decode_responses=True)
conn.set('age',10)
print(conn.get('age'))   # 10
conn.incr('age')   # 只要一执行，数字加一
print(conn.get('age'))   # 11
conn.incr('age',-1)   # 写负数，减
print(conn.get('age'))   # 10

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

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

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

# name对应的hash中设置一个键值对（不存在，则创建；否则，修改）
 
# 参数：
    # name，redis的name
    # key，name对应的hash中的key
    # value，name对应的hash中的value，这个value只能是字符串
 
# 注：
    # hsetnx(name, key, value),当name对应的hash中不存在当前key时则创建（相当于添加）

# 在name对应的hash中批量设置键值对
 
# 参数：
    # name，redis的name
    # mapping，字典，如：{'k1':'v1', 'k2': 'v2'}
 
# 如：
    # r.hmset('xx', {'k1':'v1', 'k2': 'v2'})

# 在name对应的hash中获取根据key获取value

# 在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')

# 获取name对应hash的所有键值
print(re.hgetall('xxx').get(b'name'))

# 获取name对应的hash中键值对的个数

# 获取name对应的hash中所有的key的值

# 获取name对应的hash中所有的value的值

# 检查name对应的hash是否存在当前传入的key

# 将name对应的hash中指定key的键值对删除
print(re.hdel('xxx','sex','name'))

# 自增name对应的hash中的指定key的值，不存在则创建key=amount
# 参数：
    # name，redis中的name
    # key， hash对应的key
    # amount，自增数（整数）

# 自增name对应的hash中的指定key的值，不存在则创建key=amount
 
# 参数：
    # name，redis中的name
    # key， hash对应的key
    # amount，自增数（浮点数）
 
# 自增name对应的hash中的指定key的值，不存在则创建key=amount

# 增量式迭代获取，对于数据大的数据非常有用，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时，表示数据已经通过分片获取完毕

# 利用yield封装hscan创建生成器，实现分批去redis中获取数据
 
# 参数：
    # match，匹配指定key，默认None 表示所有的key
    # count，每次分片最少获取个数，默认None表示采用Redis的默认分片个数
 
# 如：
    # for item in r.hscan_iter('xx'):
    #     print（item）    # 生成器

# 以后想取出hash类型内所有的数据，不建议用hgetall，建议用hscan_iter
# 一次性先取一部分回来（假设有1w条，先取回100条，把这100条做成了生成器）

# 在name对应的list中添加元素，每个新的元素都添加到列表的最左边
 
# 如：
    # r.lpush('oo', 11,22,33)
    # 保存顺序为: 33,22,11
 
# 扩展：
    # rpush(name, values) 表示从右向左操作

# 在name对应的list中添加元素，只有name已经存在时，值添加到列表的最左边
 
# 更多：
    # rpushx(name, value) 表示从右向左操作

# name对应的list元素的个数

# 在name对应的列表的某一个值前或后插入一个新值
 
# 参数：
    # name，redis的name
    # where，BEFORE或AFTER(小写也可以)
    # refvalue，标杆值，即：在它前后插入数据（如果存在多个标杆值，以找到的第一个为准）
    # value，要插入的数据


# 示例：
import redis

# 连接对象
conn = redis.Redis(host='127.0.0.1', port=6379, decode_responses=True)
ret = conn.linsert('list1', 'before', '888', '777')
print(ret)

# 对name对应的list中的某一个索引位置重新赋值
 
# 参数：
    # name，redis的name
    # index，list的索引位置（索引从零开始和列表一样）
    # value，要设置的值

# 在name对应的list中删除指定的值
 
# 参数：
    # name，redis的name
    # value，要删除的值
    # count， count=0，删除列表中所有的指定值；
                # count=2,从前到后，删除2个；
                # count=-2,从后向前，删除2个

# 示例：
conn.lrem('list1', 2, '888')    # 将list1中的值'888'从前往后删2个

# 在name对应的列表的左侧获取第一个元素并在列表中移除，返回值则是第一个元素
 
# 更多：
    # rpop(name) 表示从右向左操作

# 在name对应的列表中根据索引获取列表元素
# 示例：
conn.lindex('list1',0)   # 取list1中索引为0的对应的值

# 在name对应的列表分片获取数据
# 参数：
    # name，redis的name
    # start，索引的起始位置
    # end，索引结束位置 
# 示例：
conn.lrange('list1', 0, 2)   取list1的0-2索引的值，左闭右闭

# 在name对应的列表中移除没有在start-end索引之间的值
# 参数：
    # name，redis的name
    # start，索引的起始位置
    # end，索引结束位置（大于列表长度，则代表不移除任何）

# 示例
ret=conn.ltrim('list1',1,2)   # 只留下list1的1-2索引对应的值，其他的都去除

# 从一个列表取出最右边的元素，同时将其添加至另一个列表的最左边
# 参数：
    # src，要取数据的列表的name
    # dst，要添加数据的列表的name

# 将多个列表排列，按照从左到右去pop对应列表的元素
 
# 参数：
    # keys，redis的name的集合
    # timeout，超时时间，当元素所有列表的元素获取完之后，阻塞等待列表内有数据的时间（秒）, 0 表示永远阻塞
 
# 更多：
    # brpop(keys, timeout)，从右向左获取数据爬虫实现简单分布式：多个url放到列表里，往里不停放URL，程序循环取值，但是只能一台机器运行取值，可以把url放到redis中，多台机器从redis中取值，爬取数据，实现简单分布式


# block,阻塞,可以写一个超时时间
# ret=conn.blpop('list1',timeout=10)
# print(ret)

# 从一个列表的右侧移除一个元素并将其添加到另一个列表的左侧
 
# 参数：
    # 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)

# 删除redis中的任意数据类型
# 示例：
ret=conn.delete('list1')
print(ret)

# 检测redis的name是否存在

# 根据模型获取redis的name
 
# 更多：
    # KEYS * 匹配数据库中所有 key 。
    # KEYS h?llo 匹配 hello ， hallo 和 hxllo 等。
    # KEYS h*llo 匹配 hllo 和 heeeeello 等。
    # KEYS h[ae]llo 匹配 hello 和 hallo ，但不匹配 hillo

# 为某个redis的某个name设置超时时间

# 对redis的name重命名为

# 将redis的某个值移动到指定的db下

# 随机获取一个redis的name（不删除）

# 获取name对应值的类型

# 同字符串操作，用于增量迭代获取key

# redis支持事务,是使用pipline，但不是传统关系型数据库那样带回滚的，而是一次性批量全执行，要么全成功，要么全失败
# 管道。实现事务
import redis
# 这个池没做成单例，实际应该做成单例
pool = redis.ConnectionPool(host='127.0.0.1', port=6379)

conn = redis.Redis(connection_pool=pool)

# pipe = r.pipeline(transaction=False)
pipe = conn.pipeline(transaction=True)
pipe.multi()
pipe.set('name', 'alex')

pipe.set('role', 'sb')

pipe.execute()  # 配置transaction=True，只有执行execute()这句话，set才真正的去执行

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('获取成功')

# pip install django-redis

# 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",
        }
    }
}

# 1、直接操作redis对象，同方法一一样
from django_redis import get_redis_connection

conn = get_redis_connection('default')  # default就是上面settings中配置的key
conn.hmset('xx', {'k1': 'v1', 'k2': 'v2'})
print(conn.hgetall('xx'))

# 2、操作cache模块直接操作缓存：views.py
from django.core.cache import cache  # 结合配置文件实现插拔式
# 存放token，可以直接设置过期时间
cache.set('token', 'header.payload.signature', 300)
# 取出token
token = cache.get('token')

from rest_framework.mixins import ListModelMixin
from rest_framework.viewsets import GenericViewSet
from . import models
from . import serializers
from django.conf import settings
from django.core.cache import cache
from rest_framework.response import Response

# 轮播图
# class BannerView(GenericAPIView, ListModelMixin):    # 路由配置：path('banner/', views.BannerView.as_view())
class BannerView(GenericViewSet, ListModelMixin):  # 路由配置：    path('', include(router.urls))
    # 无论有多少条待展示的数据，最多就展示三条
    queryset = models.Banner.objects.filter(is_delete=False, is_show=True).order_by('display_order')[
               :settings.BANNER_COUNT]
    serializer_class = serializers.BannerSerializer

    # 重写list方法，因为要将首页轮播图这个接口数据缓存到redis中
    def list(self, request, *args, **kwargs):
        # 请求来了之后先到redis中拿data数据，拿不到再调用父类方法，到数据库中拿,拿到之后并将数据缓存到redis中
        banner_list = cache.get('banner_list')
        if not banner_list:
            # 重调父类方法
            response = super().list(request, *args, **kwargs)
            # 将数据缓存到redis中,设置过期实际为1天
            cache.set("banner_list", response.data, 60*60*24)
            return response

        return Response(data=banner_list)