Redis的学习与使用

痛定思痛。 2021-09-21 06:44 405阅读 0赞

# Redis的学习与使用 #

本文是基于Redis-4.0.11环境，学习和使用Redis：

*  **Redis-4.0.11**

--------------------

## 一、Redis相关命令 ##

### （1）数据结构 ###

String 等同于Java中的 Map<String, String>
    list 等同于Java中的 Map<String, List<String>>
    set 等同于Java中的 Map<String, Set<String>>
    sort_set 可排序set
    hash 等同于Java中的 Map<String, Map<String, String>>

### （2）通用命令 ###

*  **keys pattern匹配模式**

keys * # 查询所有的键 ---慎用

*  **set key value**  
    设置key的值为value

set k1 v1

*  **type key**  
    查看key的类型

type name  # string

*  **exists key**  
    判断一个键是否存在，存在返回1，否则返回0

exists name

*  **move key db**  
    将某个key移动到db库

move k1 2

*  **del key**  
    删除key，成功返回1，否则返回0

del name

*  **del key1 key2 key3 key4**  
    删除一组key，成功返回4，否则返回0

del k1 k2 k3 k4

*  **select index**  
    切换Redis库，index从0-15

select 2

*  **expire key seconds**  
    设置key的过期时间，单位为秒，设置成功返回1，否则返回0

expire name 20

*  **ttl key**  
    查看key的可活时间

ttl name  # -1表示永不过期， -2表示已过期

*  **save**  
    手动保存rdb文件

save

### （3）字符串命令 ###

*  **set key**  
    设置一个键值对

set name "jack"

*  **get key**  
    获取一个键值对

get name

*  **strlen key**  
    获取一个键为key的value字符串长度

strlen name

*  **append key vvv**  
    追加字符串

get k1 # v1
    append k1 vvv
    get k1 # v1vvv

*  **incr key**  
    自增加1，仅对数字有效

set k2 2 # 2
    incr k2
    get k2 # 3

*  **incrby key num**  
    自增加num，仅对数字有效

set k2 2 # 2
    incrby k2 2
    get k2 # 4

*  **decr key**  
    自减1，仅对数字有效

set k2 2 # 2
    decr k2
    get k2 # 1

*  **decrby key num**  
    自减num，仅对数字有效

set k2 3 # 3
    decrby k2 2
    get k2 # 1

*  **getrange key 0 3**  
    获取部分字符串的值

set k2 abc123 # abc123
    getrange k2 0 3
    get k2 # abc1

*  **setrange key 0 xxx**  
    设置部分字符串的值

set k2 abc123 # abc123
    getrange k2 0 3
    get k2 # abc1

*  **setex k1 10 v1**  
    设置值时，附带一个有效时间

setex k2 10 abc123 # abc123

*  **setnx k1 v1**  
    设置值时，如果k1没有值，则设置为v1，如果k1有值，则不修改

setnx k1 v1 # abc123

*  **mset k1 v1 k2 v2**  
    批量设置值

mset k1 v1 k2 v2

*  **mget k1 k2**  
    批量获取值

mget k1 k2

*  **msetnx k1 v1 k2 v2**  
    批量设置值

mset k1 v1 k2 v2

### （4）list命令 ###

*  **性能分析**

1.  它是字符串链表，left、right都可以插入添加元素
2.  如果键不存在，则创建新的链表
3.  如果键存在，则添加新的内容
4.  如果值全部移除，那么对应的链表则消失
5.  链表对中间元素的操作，性能很慢，但是对头和尾的效率很高

*  **lpush key 1 2 3**  
    从左侧push元素至列表list

lpush k1 1 2 3 # 3 2 1

*  **rpush key 1 2 3**  
    从右侧push元素至列表list

rpush k1 1 2 3 # 1 2 3

*  **lrange key 0 -1**  
    从头到尾打印列表list

lrange k1 # 1 2 3

*  **lpop key**  
    从左侧pop元素并打印

lpop k1 # 3

*  **rpop key**  
    从右侧pop元素并打印

rpop k1 # 1

*  **lindex key 2**  
    打印索引下标为2的元素

lindex k1 # 3

*  **llen key**  
    获取一个键为key的list列表大小

llen l1

*  **lrem key N value**  
    删除N个值value的list元素

# l1 2 2 3 3 3 4 4 
    lrem l1 2 3 
    lrange l1 0 -1
    # 2 2 3 4 4

*  **ltrim key start end**  
    从索引下标为start到end

# l1 2 2 3 3 3 4 4 
    ltrim l1 1 2
    lrange l1 0 -1
    # 2 3

*  **rpoplpush l1 l2**  
    从l1的右侧pop一个元素，然后再push到l2列表中

# l1 1 2 3
    # l2 4 5 6
    rpoplpush l1 l2
    lrange l2 0 -1
    # 3 4 5 6

*  **lset key index value**  
    将索引下标为index的元素设置值为value

# l1 1 2 3 
    lset l1 1 4
    lrange l1 0 -1
    # 1 4 3

*  **linsert key before/after value newValue**  
    在列表中的value值之前/之后添加新元素newValue

# l1 1 2 3 
    linsert l1 before 3 x 
    lrange l1 0 -1
    # 1 2 x 3
    linsert l1 after 3 y
    lrange l1 0 -1
    # 1 2 x 3 y

### （6）set命令 ###

*  **sadd key v1 v2 v3**  
    向set中添加元素

sadd set01 1 1 2 2 3 3
    smembers set01

*  **spop key**  
    随机pop出一个元素

srandmember set01 3

*  **smembers key**  
    打印set中所有元素

smembers set01

*  **sismember key v1**  
    判断set中是否有值为v1的元素

sismember set01 v1

*  **scard key**  
    获取set的长度

scard set01

*  **srandmember key size**  
    随机给出size个元素

srandmember set01 3

*  **smove key1 key2 valueOfKey1**  
    将key1中的值为valueOfKey1元素，迁移到key2中

smove key1 key2 5

*  **sdiff key1 key2**  
    差集，在key1中，而且不在key2中的元素

sdiff key1 key2

*  **sinter key1 key2**  
    交集，在key1中，而且在key2中的元素

sinter key1 key2

*  **sunion key1 key2**  
    并集

sunion key1 key2

### （7）hash命令 ###

*  **hset key value1 v1**  
    设置一个键值对

hset user01 name "rose"
    hset user01 age 11

*  **hget user01 name**  
    获取一个键值对的指定字段

hgetall user01 name

*  **hgetall user01**  
    获取所有的键值对

hgetall user01

*  **hmset key id 11 name li age 26**  
    设置多个键值对

hmset key id 11 name li age 26

*  **hdel key value1**  
    删除一个key的某一个字段

hdel key name

*  **hlen key**  
    获取hash的长度

hlen key

*  **hexists hash01 在hash01中的某个key是否存在**  
    判断在hash01中的某个key是否存在

hexists hash01 key

*  **hkeys key**  
    获取hash所有的key

hkeys key

*  **hvalues key**  
    获取hash所有的value

hvalues key

*  **hincrby hash01 age**  
    将key为age的元素的值增加2

hincrby hash01 age 2

*  **hincrbyfloat hash01 age 2.3**  
    将key为age的元素的值增加2.3

hincrbyfloat hash01 age 2.3

*  **hsetnx hash01 key v1**  
    如果key已经存在，则设置失败；如果不存在，那么设置成功

hsetnx hash01 key v1

### （8）zset命令 ###

在set的基础上，增加一个score

*  **zadd zset01 60 v1 70 v2**  
    向zset中添加元素

zadd zset01 60 v1 70 v2

*  **zrange zset01 0 -1**  
    打印zset中所有的元素

zrange zset01 0 -1

*  **zrevrange zset01 0 -1**  
    逆序打印zset中所有的元素

zrevrange zset01 0 -1

*  **zrange zset01 0 -1 withscores**  
    打印zset中所有的元素及score

zrange zset01 0 -1 withscores

*  **zrange zset01 score1 score2**  
    打印zset中元素的score在60-90之间

zrange zset01 60 90

*  **zrange zset01 score1 score2 withscores**  
    打印zset中元素的score在60-90之间及score分值

zrange zset01 60 90 withscores

*  **zrange zset01 score1 (score2**  
    打印zset中元素的score在60-90之间，且不包含90

zrange zset01 60 (90

*  **zrange zset01 score1 score2 limit 2 2**  
    此处的limit与SQL语句中的limit功能一致

zrange zset01 60 90 limit 2 2

*  **zrem zset01 key1**  
    删除元素key1

zrem zset01 key1

*  **zcard zset01**  
    打印zset01的个数

zcard zset01

*  **zcount zset01 60 80**  
    打印zset01中score在60-80之间的元素个数

zcount zset01 60 80

*  **zrank zset01 v4**  
    获得v4的正序下标

zrank zset01 v4

*  **zrevrank zset01 v4**  
    获得v4的逆序下标

zrevrank zset01 v4

*  **zscore zset01 v4**  
    获得v4的score

zscore zset01 v4

*  **zrerangebyscore zset01 score2 score1**  
    逆序打印score在score2和score1之间的元素

zrerangebyscore zset01 90 60

## 二、Redis的安装和配置 ##

### （1）安装 ###

*  **解压安装包**

tar -xzvf redis-4.0.11.tar.gz -C /opt/module

*  **安装gcc**

yum install -y gcc

*  **编译并安装redis**

cd /opt/module/redis-4.0.11
    make
    make install # 默认安装在/usr/local/bin目录下

*  **启动redis服务端**

redis-server /opt/module/redis/conf/redis.conf

*  **启动redis客户端**

redis-cli
    redis-cli -h 192.168.202.201 -p 6379

*  **redis常用配置**

daemonize yes

### （2）Gereral配置 ###

*  **设置Redis以守护进程启动**

daemonize yes
    bind 192.168.232.201 127.0.0.1
    pidfile /var/run/redis_6379.pid
    port 6379
    logfile "/opt/moduel/redis/logs/redis.log"  # 设置log日志的存储路径
    # RDB配置
    dbfilename dump.rdb
    dir /opt/module/redis/data
    save 900 1
    save 300 10
    save 60 10000
    # AOF配置
    appendonly yes # 默认情况是 no
    appendfilename appendonly.aof
    appendfsync everysec

*  **设置Redis服务的pid存储文件路径**

pidfile /var/run/redis_6379.pid

*  **设置log日志级别**
 *  一般设备为verbose

# debug (a lot of information, useful for development/testing)
    # verbose (many rarely useful info, but not a mess like the debug level)
    # notice (moderately verbose, what you want in production probably)
    # warning (only very important / critical messages are logged)
    loglevel verbose # 设置log日志级别

*  **设置log日志的存储路径**

# stdout 标准输出
    # stderr 标准错误输出
    logfile ""  # 设置log日志的存储路径

*  **设置系统日志的开关**

syslog-enabled no  # yes 开启

*  **设置系统日志的标识**

syslog-ident redis  # 系统日志文件以redis为开头

*  **设置输出系统日志的设备**

syslog-facility local0  # 设备名称必须为local0-local7

*  **设置redis中数据库的个数**

databases 16  # 0 - 15

### （3）Network配置 ###

*  **设置Redis服务的端口号**

port 6379

*  **设置backlog值**  
    在高并发环境下，需要设置一个较大的值来避免慢客户端连接问题

tcp-backlog 511

*  **设置超时时间**  
    超时N秒后，关闭客户端连接，一般设置300

timeout 0  # 0 表示禁用超时，一直连接，不关闭

*  **设置keepalive检测时间**  
    经过N秒后，进行keepalive检测

tcp-keepalive 0  # 0 表示不会进行keepalive检测

*  **设置绑定主机**

bind 127.0.0.1

### （4）limits配置 ###

*  **设置最大客户端连接数**

maxclients 10000

*  **设置缓存大小**

maxmemory <bytes>

*  **设置缓存过期清除策略**

# volatile-lru：使用LRU算法移除key，只对设置了过期时间的key生效，LRU最小使用次数
    # allkeys-lru -> 使用LRU算法移除key
    # volatile-lfu -> 使用LFU算法移除key，只对设置了过期时间的key生效，LFU最小使用频率
    # allkeys-lfu -> 使用LFU算法移除key
    # volatile-random -> 随机移除key，只对设置了过期时间的key生效
    # allkeys-random -> 随机移除key
    # volatile-ttl -> 移除那些TTL值最小的key
    # noeviction -> 不使用过期策略
    maxmemory-policy noeviction

*  **设置样本数量**  
    由于LRU、LFU、TTL都是采用近似算法，需要通过采用进行评估，样本是为3，速度快但是不准确，样本数10，准确但是慢

maxmemory-samples 5

### （5）SNAPSHOTTING配置 ###

*  **设置本地数据库存放路径**

dir ./

*  **设置触发rdb持久化条件**

save 900 1
    save 300 10
    save 60 10000

*  **设置rdb文件的名称**

dbfilename dump.rdb

*  **设置出错控制**

stop-writes-on-bgsave-error yes

*  **设置是否启用压缩**

rdbcompression yes

*  **设置是否启用校验和**

rdbchecksum yes

### （6）Append Only Mode ###

*  **设置append only模式**

appendonly yes # 默认情况是 no

*  **设置aof文件的名称**

appendfilename appendonly.aof

*  **设置aof同步策略**

# no: 不同步
    # always: 每发生一次写操作，就会记录一次，性能较差但数据完整性好
    # everysec: 每秒发生一次记录
    appendfsync everysec

*  **设置重写时是否可以运用appendfsync**  
    重写时是否可以运用appendfsync，用默认no即可，保证数据安全性

no-appendfsync-on-rewrite no

*  **设置aof重写基准值**

# 高并发情况下为3G
    auto-aof-rewrite-min-size 2048mb

*  **设置aof重写基准值**

auto-aof-rewrite-percentage 100

## 三、Redis持久化 ##

### （1）Redis持久化是什么 ###

RDB+AOF  
redis database  
append only file

### （2）RDB ###

*  **1. RDB是什么**  
    redis会单独创建一个子进程来进行持久化，先将数据写入到一个临时文件，待持久化过程结束后，再将这个临时文件替换上次持久化好的文件。RDB的缺点是最后一次持久化后的数据可能丢失
 *  **2. Fork**  
    fork的作用就是复制一个与当前进程一样的进程，新进程的所有数据（变量、环境变量等）都和原进程一致，但是是一个全新的进程，并作为原进程的子进程。
 *  **3. RDB的存储形式**  
    RDB存储为一个dump.rdb文件
 *  **4. RDB如何恢复**  
    将备份文件dump.rdb移动到redis启动目录，并启动redis
 *  **5. RDB优势**  
    1.适合大规模的数据恢复  
    2.对数据完整性和一致性的要求不高
 *  **6. RDB劣势**  
    1.可能会丢失最后一次快照后更新的数据  
    2.fork进程后会复制原进程的所有数据，内存会膨胀2倍

### （3）AOF ###

*  **1. AOF是什么**  
    以日志的形式来记录每个写操作，将redis执行过的所有写指令记录下来（读操作不记录），只许追加文件但不可以改写文件，redis启动之初会读取该文件重新构建数据，换言之，redis重启的话就根据日志文件的内容将写指令从前到后执行一次以完成数据的恢复工作
 *  **2. AOF的存储形式**  
    AOF存储为一个appendonly.aof文件
 *  **3. AOF文件启动**  
    修改配置文件appendonly yes  
    将appendonly.aof文件复制到redis的启动目录，重启redis即可恢复数据
 *  **4. AOF文件出错后如何恢复**  
    使用redis-check-aof --fix命令修复appendonly.aof文件
 *  **5. rewrite定义**  
    aof采用文件追加方式，文件会越来越大为避免出现此种情况，新增了重写机制，当aof文件的大小超过所设定的阈值时，redis会启动aof文件的内容压缩，只保留可以恢复数据的最小指令集，可以使用命令bgrewriteaof
 *  **6. rewrite重写原理**  
    aof文件持续增长而过大时，会fork出一条新进程来将文件重写（也是先写临时文件最后再rename），遍历新进程的内存中数据，每条记录有一条的set语句。重写aof文件的操作，并没有读取旧的aof文件，而是将整个内存中的数据库内容用命令的方式重写了一个新的aof文件，这点和快照有点类似。
 *  **7. rewrite触发机制**  
    redis会记录上次重写时aof文件的大小，默认配置是当aof文件大小是上次rewrite后大小的一倍且文件大于64M时触发
 *  **8. AOF优势**  
    1.多种同步更新策略，实时同步，每秒同步，不同步
 *  **9. AOF劣势**  
    1.相同数据集情况下，aof文件要比rdb大很多，恢复速度也比rdb慢  
    2.aof运行速率要慢于rdb，每秒同步策略效率较好，不同步效率和rdb相同

### （4）Redis持久化总结 ###

如果只做缓存，可以不做持久化  
同时开启两种持久化方式，当重启redis时，会优先加载aof文件来恢复原始数据，以为aof丢数据比rdb少；rdb更适合用于备份数据库（aof在不断变化不好备份），快速重启，而且不会有aof可能潜在的bug。

## 四、Redis事务 ##

### （1）Redis事务定义 ###

一组命令在执行过程中，是按照顺序执行，不会被其他命令插入

### （2）Redis事务能做什么 ###

一个队列中，一次性、顺序性、排他性的执行一系列命令

### （3）事务常用命令 ###

*  **discard**  
    取消事务，放弃执行事务块内的所有命令
 *  **exec**  
    执行事务块内的所有命令
 *  **multi**  
    标记一个事务块的开启
 *  **unwatch**  
    取消watch命令对所有key的监视
 *  **watch key \[key1 …\]**  
    监视某个key或多个key，如果在执行事务之前，某个key被其他命令改动了，那么事务将会被打断

### （4）redis部分支持事务 ###

*  **冤头债主**

set k1 v1
    set k2 v2
    multi
    incr k1
    set k2 aa
    exec
    # 执行结果
    127.0.0.1:6379> exec
    1) (error) ERR value is not an integer or out of range
    2) OK
    # k2设置aa成功，但是k1执行incr执行失败

## 五、Redis主从复制 ##

### （1）定义 ###

主机数据更新后根据配置和策略，自动同步到各机的master/slave机制，master以写为主，slave以读为主

### （2）能干什么 ###

读写分离  
容灾恢复

### （3）如何配置 ###

*  **配从库，不配主库**

# 开启守护进程运行
    daemonize yes
    pidfile /var/run/redis_6379.pid
    port 6379
    logfile "6379.log"
    dbfilename dump_6379.rdb

*  **从库配置**

slaveof 127.0.0.1 6379

## 六、Spring Data Redis ##

### （1）存储验证码 ###

*  **引入依赖**

<dependency>
    	<groupId>org.springframework.boot</groupId>
    	<artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>

*  **配置Redis**

spring:
      redis:
        host: 192.168.0.207
        port: 6379

*  **验证码存储到Redis**

@Service
    public class UserService { 
        @Autowired
        private UserMapper userMapper;
        @Autowired
        private AmqpTemplate amqpTemplate;
        @Autowired
        private StringRedisTemplate redisTemplate;
    
        private static final String KEY_PREFIX = "user:verify:";
    
        public void sendVerifyCode(String phone) { 
            String code = NumberUtils.generateCode(6);
            Map<String, String> msg = new HashMap<>();
            msg.put("phone", phone);
            msg.put("code", code);
            this.amqpTemplate.convertAndSend("zs200a.exchange", "verifycode.sms", msg);
            this.redisTemplate.opsForValue().set(KEY_PREFIX + phone, code, 5, TimeUnit.MINUTES);
        }
    }

--------------------