redis入门学习（比较全面）

一、 安装

在centOs下安装redis

首先需要安装gcc依赖用于编译解压后的redis

就把gcc当成c语言编译器, g++当成c++语言编译器用就是了

yum -y install gcc gcc-c++ autoconf pcre pcre-devel make automake

下载redis压缩包并且解压编译

$ wget http://download.redis.io/releases/redis-5.0.3.tar.gz
$ tar xzf redis-5.0.3.tar.gz
$ cd redis-5.0.3
$ make

这个时候redis已经安装完成但是也可以使用一下命令将redis安装到自定义的目录中

make install PREFIX=/usr/redis

二、启动Redis服务

使用默认的6379端口启动

./bin/redis-server

使用指定端口启动

• 拷贝一份redis.conf

cp redis.conf /usr/redis/redis.conf

• 修改启动端口

vim /usr/redis/redis.conf
# Accept connections on the specified port, default is 6379 (IANA #815344).
# If port 0 is specified Redis will not listen on a TCP socket.
port 7000

• 启动redis

./bin/redis-server ./redis.conf

三、连接redis

连接默认端口

./bin/redis-cli

连接指定端口

./bin/redis-cli -p 7000

四、Redis中常用的与数据库有关的指令

说明: 使用redis的默认配置器动redis服务后,默认会存在16个库,编号从0-15
可以使用select 库的编号 来选择一个redis的库

• 清空当前的库 FLUSHDB
• 清空全部的库 FLUSHALL

五、Redis中常用的与key相关的指令

1.DEL
语法 : DEL key [key …]
作用 : 删除给定的一个或多个key 。不存在的key 会被忽略。
可用版本： >= 1.0.0
时间复杂度：
O(N)，N 为被删除的key 的数量。
删除单个字符串类型的key ，时间复杂度为O(1)。
删除单个列表、集合、有序集合或哈希表类型的key ，时间复杂度为O(M)，M为以上数据结构内的元素数量。
返回值： 被删除key 的数量。
2.EXISTS
语法: EXISTS key
作用: 检查给定key 是否存在。
可用版本： >= 1.0.0
时间复杂度： O(1)
返回值： 若key 存在，返回1 ，否则返回0 。
3.EXPIRE
语法: EXPIRE key seconds
作用: 为给定key 设置生存时间，当key 过期时(生存时间为0 )，它会被自动删除。
在Redis 中，带有生存时间的key 被称为『易失的』(volatile)。生存时间可以通过使用DEL 命令来删除整个key 来移除，或者被SET 和GETSET 命令覆写(overwrite)，
这意味着，如果一个命令只是修改(alter) 一个带生存时间的key 的值而不是用一个新的key 值来代替(replace) 它的话，那么生存时间不会被改变。
比如说，对一个key 执行INCR 命令，对一个列表进行LPUSH 命令，或者对一个哈希表执行HSET 命令，这类操作都不会修改key 本身的生存时间。
另一方面，如果使用RENAME 对一个key 进行改名，那么改名后的key 的生存时间和改名前一样。RENAME 命令的另一种可能是，尝试将一个带生存时间的key 改名成另一个带生存时间的another_key这时旧的another_key (以及它的生存时间) 会被删除，然后旧的key 会改名为another_key ，因此，新的another_key 的生存时间也和原本的key 一样。使用PERSIST 命令可以在不删除key 的情况下，移除key 的生存时间，让key 重新成为一个『持久的』(persistent) key 。更新生存时间可以对一个已经带有生存时间的key 执行EXPIRE 命令，新指定的生存时间会取代旧的生存时间。过期时间的精确度在Redis 2.4 版本中，过期时间的延迟在1 秒钟之内——也即是，就算key 已经过期，但它还是可能在过期之后一秒钟之内被访问到，而在新的Redis 2.6 版本中，延迟被降低到1 毫秒之内。Redis 2.1.3 之前的不同之处
在Redis 2.1.3 之前的版本中，修改一个带有生存时间的key 会导致整个key 被删除，这一行为是受当时复制(replication) 层的限制而作出的，现在这一限制已经被修复。
可用版本： >= 1.0.0
时间复杂度： O(1)
返回值：设置成功返回1 。
4.KEYS
语法 : KEYS pattern
作用 : 查找所有符合给定模式pattern 的key 。
KEYS * 匹配数据库中所有key 。
KEYS h?llo 匹配hello ，hallo 和hxllo 等。
KEYS h*llo 匹配hllo 和heeeeello 等。
KEYS h[ae]llo 匹配hello 和hallo ，但不匹配hillo 。
特殊符号用 \ 隔开
注意: KEYS 的速度非常快，但在一个大的数据库中使用它仍然可能造成性能问题，如果你需要从一个数据集中查找特定的key ，你最好还是用Redis 的集合结构(set) 来代替。
可用版本： >= 1.0.0
时间复杂度： O(N)，N 为数据库中key 的数量。
返回值： 符合给定模式的key 列表。
5.MOVE
语法 : MOVE key db
作用 : 将当前数据库的key 移动到给定的数据库db 当中。
如果当前数据库(源数据库) 和给定数据库(目标数据库) 有相同名字的给定key ，或者key 不存在于当前数据库，那么MOVE 没有任何效果。因此，也可以利用这一特性，将MOVE 当作锁(locking) 原语(primitive)。
可用版本： >= 1.0.0
时间复杂度： O(1)
返回值： 移动成功返回1 ，失败则返回0 。
6.PEXPIRE
语法 : PEXPIRE key milliseconds
作用 : 这个命令和EXPIRE 命令的作用类似，但是它以毫秒为单位设置key 的生存时间，而不像EXPIRE 命令那样，以秒为单位。
可用版本： >= 2.6.0
时间复杂度： O(1)
返回值：设置成功，返回1 key 不存在或设置失败，返回0
7.PEXPIREAT
语法 : PEXPIREAT key milliseconds-timestamp
作用 : 这个命令和EXPIREAT 命令类似，但它以毫秒为单位设置key 的过期unix 时间戳，而不是像EXPIREAT那样，以秒为单位。
可用版本： >= 2.6.0
时间复杂度： O(1)
返回值：如果生存时间设置成功，返回1 。当key 不存在或没办法设置生存时间时，返回0 。(查看EXPIRE 命令获取更多信息)
8.TTL
语法 : TTL key
作用 : 以秒为单位，返回给定key 的剩余生存时间(TTL, time to live)。
可用版本： >= 1.0.0
时间复杂度： O(1)
返回值：
当key 不存在时，返回-2 。
当key 存在但没有设置剩余生存时间时，返回-1 。
否则，以秒为单位，返回key 的剩余生存时间。
Note : 在Redis 2.8 以前，当key 不存在，或者key 没有设置剩余生存时间时，命令都返回-1 。
9.PTTL
语法 : PTTL key
作用 : 这个命令类似于TTL 命令，但它以毫秒为单位返回key 的剩余生存时间，而不是像TTL 命令那样，以秒为单位。
可用版本： >= 2.6.0
复杂度： O(1)
返回值： 当key 不存在时，返回-2 。当key 存在但没有设置剩余生存时间时，返回-1 。
否则，以毫秒为单位，返回key 的剩余生存时间。
注意 : 在Redis 2.8 以前，当key 不存在，或者key 没有设置剩余生存时间时，命令都返回-1 。
10.RANDOMKEY
语法 : RANDOMKEY
作用 : 从当前数据库中随机返回(不删除) 一个key 。
可用版本： >= 1.0.0
时间复杂度： O(1)
返回值：当数据库不为空时，返回一个key 。当数据库为空时，返回nil 。
11.RENAME
语法 : RENAME key newkey
作用 : 将key 改名为newkey 。当key 和newkey 相同，或者key 不存在时，返回一个错误。当newkey 已经存在时，RENAME 命令将覆盖旧值。
可用版本： >= 1.0.0
时间复杂度： O(1)
返回值： 改名成功时提示OK ，失败时候返回一个错误。
12.TYPE
语法 : TYPE key
作用 : 返回key 所储存的值的类型。
可用版本： >= 1.0.0
时间复杂度： O(1)
返回值：
none (key 不存在)
string (字符串)
list (列表)
set (集合)
zset (有序集)
hash (哈希表)

六、Redis的数据类型

Redis的String类型的数据操作

命令	说明
set	设置一个key/value
get	根据key获得对应的value
mset	一次设置多个key value
mget	一次获得多个key的value
getset	获得原始key的值，同时设置新值
strlen	获得对应key存储value的长度
append	为对应key的value追加内容
getrange	截取value的内容
setex	设置一个key存活的有效期（秒）
psetex	设置一个key存活的有效期（毫秒）
setnx	存在不做任何操作,不存在添加
msetnx	可以同时设置多个key,只有有一个存在都不保存
decr	进行数值类型的-1操作
decrby	根据提供的数据进行减法操作
Incr	进行数值类型的+1操作
incrby	根据提供的数据进行加法操作
Incrbyfloat	根据提供的数据加入浮点数

Redis的List类型的操作

• 数据结构图
  

命令	说明
lpush	将某个值加入到一个key列表头部
lpushx	同lpush,但是必须要保证这个key存在
rpush	将某个值加入到一个key列表末尾
rpushx	同rpush,但是必须要保证这个key存在
lpop	返回和移除列表的第一个元素
rpop	返回和移除列表的第一个元素
lrange	获取某一个下标区间内的元素
llen	获取列表元素个数
lset	设置某一个指定索引的值(索引必须存在)
lindex	获取某一个指定索引位置的元素
lrem	删除重复元素
ltrim	保留列表中特定区间内的元素
linsert	在某一个元素之前，之后插入新元素

• 举例

#创建并且加入"zhangsan"到列表中
$ LPUSH name zhangsan
(integer) 1
#查看name类型
$ type name
list
#查看list列表的长度
$ llen name
(integer) 2
#在lisi元素之前插入wangwu
$ LINSERT name BEFORE lisi wangwu
(integer) 3
#查看索引为0-2的元素
$ LRANGE name 0 2
1) "wangwu"
2) "lisi"
3) "zhangsan"

Redis的SET类型的操作

• 数据结构图
  

命令	说明
sadd	为集合添加元素
smembers	显示集合中所有元素 无序
scard	返回集合中元素的个数
spop	随机返回一个元素
smove	从一个集合中向另一个集合移动元素
srem	从集合中删除一个元素
sismember	判断一个集合中是否含有这个元素
srandmember	随机返回元素
sdiff	去掉第一个集合中其它集合含有的相同元素
sinter	求交集
sunion	求和集

• 举例

#创建一个set并加入“flag1”
SADD myset flag1
(integer) 1
SADD myset flag2
(integer) 1
 SADD myset flag3
(integer) 1
#显示集合中所有元素 无序
SMEMBERS myset
1) "flag1"
2) "flag3"
3) "flag2"
(integer) 1
#求和集
SUNION set myset  myset2
1) "flag2"
2) "flag3"
3) "flag4"
4) "flag1"
5) "flag6"
6) "flag5"
#判断一个集合中是否含有这个元素
SISMEMBER myset flag1
(integer) 1
 SISMEMBER myset flag7
(integer) 0

Redis的ZSET类型的操作 sortset

数据结构

命令	说明
zadd	添加一个有序集合元素
zcard	返回集合的元素个数
zrange	返回一个范围内的元素
zrangebyscore	按照分数查找一个范围内的元素
zrank	返回排名
zrevrank	倒序排名
zscore	显示某一个元素的分数
zrem	移除某一个元素
zincrby	给某个特定元素加分

举例

 ZADD myset 1.00 flag1
(integer) 1
ZADD myset 2.00 flag2
(integer) 1
 ZADD myset 3.00 flag3
(integer) 1
 keys myset
1) "myset"
 type myset
zset
 ZRANGE myset 1 2
1) "flag2"
2) "flag3"
ZRANGE myset 1 3
1) "flag2"
2) "flag3"
 ZREVRANGE myset 1 3
1) "flag2"
2) "flag1"
127.0.0.1:6379> ZREVRANGE myset 0 3
1) "flag3"
2) "flag2"
3) "flag1"
127.0.0.1:6379> ZINCRBY myset 0.1 flag1
"1.1000000000000001"

Redis的HASH类型的操作

数据结构

命令	说明
hset	设置一个key/value对
hget	获得一个key对应的value
hgetall	获得所有的key/value对
hdel	删除某一个key/value对
hexists	判断一个key是否存在
hkeys	获得所有的key
hvals	获得所有的value
hmset	设置多个key/value
hmget	获得多个key的value
hsetnx	设置一个不存在的key的值
hincrby	为value进行加法运算
hincrbyfloat	为value加入浮点值

举例

127.0.0.1:6379> HSET myhash name zhangsan
(integer) 1
127.0.0.1:6379> HSET myhash age 12
(integer) 1
127.0.0.1:6379> HSET myhash sex 男
(integer) 1
127.0.0.1:6379> HSET myhash class 110
(integer) 1
127.0.0.1:6379> hget myhash class
"110"
127.0.0.1:6379> hget myhash sex
"\xe7\x94\xb7"
127.0.0.1:6379> hdel myhash sex
(integer) 1
127.0.0.1:6379> hkeys myhash
1) "name"
2) "age"
3) "class"
127.0.0.1:6379> hmset myhash number 6666 score 100
OK
127.0.0.1:6379> hkeys myhash
1) "name"
2) "age"
3) "class"
4) "number"
5) "score"
127.0.0.1:6379> hmget myhash age name class
1) "12"
2) "zhangsan"
3) "110"
127.0.0.1:6379> HINCRBY myhash class 15
(integer) 125
127.0.0.1:6379> hset myhash floatfiled 12.36
(integer) 1
127.0.0.1:6379> hincrbyfloat floatfiled 12.36 12.56
"12.56"
127.0.0.1:6379> HVALS myhash
1) "zhangsan"
2) "12"
3) "125"
4) "6666"
5) "100"
6) "12.36"

七、Redis中的持久化机制

Redis提供了两种不同的持久化方法来将数据存储到硬盘里面

快照(snapshotting)

这种方式可以将某一时刻的所有数据都写入硬盘中,当然这也是redis的默认持久化方式,保存的文件是以.rdb形式结尾的文件因此这种方式也称之为RDB方式

快照持久化也是redis中的默认开启的持久化方案, 根据redis.conf中的配置,快照将被写入dbfilename指定的文件里面(默认是dump.rdb文件中)

# The filename where to dump the DB
dbfilename dump.rdb

根据redis.conf中的配置,快照将保存在dir选项指定的路径上

# Note that you must specify a directory here, not a file name.
dir ./

创建快照的几种方式

• 客户端可以使用BGSAVE命令来创建一个快照,当接收到客户端的BGSAVE命令时,redis会调用fork（ fork当一个进程创建子进程的时候,底层的操作系统会创建该进程的一个副本,在类unix系统中创建子进程的操作会进行优化:在刚开始的时候,父子进程共享相同内存,直到父进程或子进程对内存进行了写之后,对被写入的内存的共享才会结束服务）来创建一个子进程,然后子进程负责将快照写入磁盘中,而父进程则继续处理命令请求

• 客户端还可以使用SAVE命令来创建一个快照,接收到SAVE命令的redis服务器在快照创建完毕之前将不再响应任何其他的命令

注意 : SAVE命令并不常用,使用SAVE命令在快照创建完毕之前,redis处于阻塞状态,无法对外服务

• 如果用户在redis.conf中设置了save配置选项,redis会在save选项条件满足之后自动触发一次BGSAVE命令,如果设置多个save配置选项,当任意一个save配置选项条件满足,redis也save

会触发一次BGSAVE命令配置选项

save 900 1//自上次成功保存起，如果在900秒内已经发生1次写入触发BGSAVE
save 300 10//自上次成功保存起，如果在300秒内已经发生10次写入触发BGSAVE
save 60 10000//自上次成功保存起，如果在60秒内已经发生10,000次写入触发BGSAVE

• 当redis通过shutdown指令接收到关闭服务器的请求时,会执行一个save命令,阻塞所有的客户端,不再执行客户端执行发送的任何命令,并且在save命令执行完毕之后关闭服务器

AOF(append only file)只追加文件

这种方式可以将所有客户端执行的写命令记录到日志文件中

AOF持久化机制

在redis的默认配置中AOF持久化机制 是没有开启的,AOF持久化会将被执行的写命令写到AOF的文件末尾,以此来记录数据发生的变化,因此只要redis从头到尾执行一次AOF文件所包含的所有写命令,就可以恢复AOF文件的记录的数据集.

开启AOF持久化机制,需要修改redis.conf的配置文件,

• 通过修改redis.conf配置中appendonly yes来开启AOF持久化

# Please check http://redis.io/topics/persistence for more information.
appendonly no

• 通过appendfilename指定日志文件名字(默认为:appendonly.aof)

# The name of the append only file (default: "appendonly.aof")
appendfilename "appendonly.aof"

• 通过appendfsync指定日志记录频率

# If unsure, use "everysec".
# appendfsync always //总是同步
appendfsync everysec//每秒同步一次
# appendfsync no//不开启同步

AOF 日志记录频率的选项
可选项

选项	同步频率
always	每个redis写命令都要同步写入硬盘,严重降低redis速度
everysec	每秒执行一次同步显式的将多个写命令同步到磁盘
no	由操作系统决定何时同步

• 三种日志记录频率的详细分析 :

1、如果用户使用了always选项,那么每个redis写命令都会被写入硬盘,从而将发生系统崩溃时出现的数据丢失减到最少;遗憾的是,因为这种同步策略需要对硬盘进行大量的写入操作,所以redis处理命令的速度会受到硬盘性能的限制;
注意 : 转盘式硬盘在这种频率下200左右个命令/s ; 固态硬盘(SSD) 几百万个命令/s;
警告 : 使用SSD用户请谨慎使用always选项,这种模式不断写入少量数据的做法有可能会引发严重的写入放大问题,导致将固态硬盘的寿命从原来的几年降低为几个月

2、为了兼顾数据安全和写入性能,用户可以考虑使用everysec选项,让redis每秒一次的频率对AOF文件进行同步;redis每秒同步一次AOF文件时性能和不使用任何持久化特性时的性能相差无几,而通过每秒同步一次AOF文件,redis可以保证,即使系统崩溃,用户最多丢失一秒之内产生的数据(推荐使用这种方式)

3、最后使用no选项,将完全有操作系统决定什么时候同步AOF日志文件,这个选项不会对redis性能带来影响但是系统崩溃时,会丢失不定数量的数据

另外如果用户硬盘处理写入操作不够快的话,当缓冲区被等待写入硬盘数据填满时,redis会处于阻塞状态,并导致redis的处理命令请求的速度变慢(不推荐使用)

AOF文件的重写

aof 的方式也同时带来了另一个问题。持久化文件会变的越来越大。例如我们调用incr test命令100次，文件中必须保存全部的100条命令，其实有99条都是多余的。因为要恢复数据库的状态其实文件中保存一条set test 100就够了。为了压缩aof的持久化文件Redis提供了AOF重写机制

重写 aof 文件的两种方式

执行BGREWRITEAOF命令

配置redis.conf中的auto-aof-rewrite-percentage选项

BGREWRITEAOF 方式

收到此命令redis将使用与快照类似的方式将内存中的数据 以命令的方式保存到临时文件中，最后替换原来的文件。具体过程如下

redis调用fork ，现在有父子两个进程子进程根据内存中的数据库快照，往临时文件中写入重建数据库状态的命令

父进程继续处理client请求，除了把写命令写入到原来的aof文件中。同时把收到的写命令缓存起来。这样就能保证如果子进程重写失败的话并不会出问题。

当子进程把快照内容写入已命令方式写到临时文件中后，子进程发信号通知父进程。然后父进程把缓存的写命令也写入到临时文件。

现在父进程可以使用临时文件替换老的aof文件，并重命名，后面收到的写命令也开始往新的aof文件中追加。

注意 :
重写aof文件的操作，并没有读取旧的aof文件，而是将整个内存中的数据库内容用命令的方式重写了一个新的aof文件,替换原有的文件这点和快照有点类似。(AOF重写过程完成后会删除旧的AOF文件,删除一个体积达几十GB大的旧的AOF文件可能会导致系统随时挂起
)

配置redis.conf中的auto-aof-rewrite-percentage选项

AOF重写也可以使用auto-aof-rewrite-percentage 100
和auto-aof-rewrite-min-size 64mb来自动执行BGREWRITEAOF.

说明: 如果设置auto-aof-rewrite-percentage值为100和auto-aof-rewrite-min-size
64mb,并且启用的AOF持久化时,那么当AOF文件体积大于64M,并且AOF文件的体积比上一次重写之后体积大了至少一倍(100%)时,会自动触发,如果重写过于频繁,用户可以考虑将auto-aof-rewrite-percentage设置为更大

两种持久化方案的总结

AOF持久化既可以将丢失的数据的时间降低到1秒(甚至不丢失任何数据),那么我们还有什么理由不是用AOF呢?

注意 :
这个问题实际上并没有这么简单,因为redis会不断将执行的写命令记录到AOF文件中,所以随着redis运行,AOF文件的体积会不断增大,在极端情况下甚至会用完整个硬盘,还有redis重启重新执行AOF文件记录的所有写命令的来还原数据集,AOF文件体积非常大,会导致redis执行恢复时间过长

两种持久化方案既可以同时使用,又可以单独使用,在某种情况下也可以都不使用,具体使用那种持久化方案取决于用户的数据和应用决定

无论使用AOF还是快照机制持久化,将数据持久化到硬盘都是有必要的,除了持久化外,用户还应该对持久化的文件进行备份(最好备份在多个不同地方)

后续补充

八、Java API 调用Redis

• 在项目中导入redis的驱动jar jedis的jar包即可

    redis.clients
    jedis
    2.9.0

• jdeis常用API测试

注意有些版本的redis默认开启了保护模式，直接连接会报JedisDataException异常
需要在连接端输入config set protected-mode "no"来关闭保护模式

测试代码

public class TestJavaClientRedis {
    public static void main(String[] args) {
        //创建jedis对象
        Jedis jedis = new Jedis("192.168.211.128", 6379);
        //选择要连接的数据库（默认16个库索引为0-15）
        jedis.select(0);
        //创建一个key-value
        jedis.set("String","first");
        //创建一个list
        jedis.lpush("list","list1");
        //获取list的指定范围内的value
        List<String> list = jedis.lrange("list", 0, 1);
         //创建一个hash
        Map<String, String> map = new HashMap<>();
        map.put("name","zhangsan");
        map.put("age","12");
        map.put("class","110");
        jedis.hmset("map",map);
        //获取所有的hash元素
        Map<String, String> map1 = jedis.hgetAll("map");
        for (Map.Entry<String,String> entry: map1.entrySet()) {
            System.out.println(entry);
        }     
    }
}

这里只是简单的测试一下，jedis常用API

九、Redis的集群搭建

十、集群节点的操作

十一、Spring-data操作Redis

十二、redis做缓存

十三、redis做消息队列

十四、redis做分布式锁