Redis | 易学教程

Redis简介

Redis是完全开源免费的，遵守BSD协议，是一个高性能的key-value数据库。

Redis与其他key-value缓存产品有以下三个特点：

Redis支持数据的持久化，可以将内存中的数据保存在磁盘中，重启时可以再次加载进行使用。
Redis不仅仅支持简单的key-value类型的数据，同时还提供list、set、zset、hash等数据结构的存储。
Redis支持数据的备份，即master-slave模式的数据备份。

Redis优势

性能极高-Redis能读的速度是110000次/s，写的速度是81000次/s。
丰富的数据类型-Redis支持二进制案例的strings、lists、hashes、sets及ordered sets数据类型操作。
原子-Redis的所有操作都是原子性的，意思就是要么成功执行要么失败完全不执行。单个操作是原子性的。多个操作也支持事务，即原子性，通过MULTI和EXEC指令包起来。
丰富的特性-Redis还支持publish/subscribe，通知，key过期等等特性。

下载配置数据库

Redis下载链接：https://github.com/MSOpenTech/redis/releases

下载后解压，打开cmd切换到下载目录，执行：redis-server.exe redis.windows.conf，如果配置环境变量，不需要写redis.windows.conf。再打开一个cmd窗口，切换目录下运行：redis-cli.exe -h 127.0.0.1 -p 6379

Redis免费版可视化界面下载链接：链接：https://pan.baidu.com/s/1AnVBgOHBAr2ZlGXUBhFM0g 提取码：hwhq

Redis数据类型

Redis支持五种数据类型：string（字符串）、hash（哈希）、list（列表）、set（集合）、zset（sorted set：有序集合）。

Redis键（key）

Redis键命令用于管理Redis的键

127.0.0.1:6379> SET hello redis
OK
127.0.0.1:6379> DEL hello
(integer) 1
# hello 是一个键。 如果键被删除成功，命令执行后输出 (integer) 1，否则将输出 (integer) 0

String（字符串）

string是Redis最基本的类型，一个key対应一个value，string类型的值最大能存储512MB，即一个键最大能存储512MB。

string类型是二进制安全的，也就是说Redis的string可以包含任何数据，如jpg图片或者序列化的对象。

理解：string就像是Python中的dict一样，一个key対应一个value

127.0.0.1:6379> set hello world
OK
127.0.0.1:6379> get hello
"world"
# set：设置键值对，键为hello，対应的值为world。
# get：获取键相对应的键值，当键不存在时返回nil，客户端会转换成none
# del：删除指定的键的值，当键不存在时则返回0

Hash（哈希）

Redis hash是一个键值对（key-value）集合。

Redis hash是一个string类型的key和value的映射表，hash特别适合用于存储对象。

理解：可以将hash看成一个key-value的结合。也可以将其想成一个hash対应着多个string。

与string区别：string是一个key-value键值对，而hash是多个key-value键值对。

# hash-key 可以看成是一个键值对集合的名字,在这里分别为其添加了 sub-key1 : value1、sub-key2 : value2、sub-key3 : value3 这三个键值对
127.0.0.1:6379> hset hash-key sub-key1 value1
(integer) 1
127.0.0.1:6379> hset hash-key sub-key2 value2
(integer) 1
127.0.0.1:6379> hset hash-key sub-key3 value3
(integer) 1
# 获取 hash-key 这个 hash 里面的所有键值对
127.0.0.1:6379> hgetall hash-key
1) "sub-key1"
2) "value1"
3) "sub-key2"
4) "value2"
5) "sub-key3"
6) "value3"
# 删除 hash-key 这个 hash 里面的 sub-key2 键值对
127.0.0.1:6379> hdel hash-key sub-key2
(integer) 1
127.0.0.1:6379> hget hash-key sub-key2
(nil)
127.0.0.1:6379> hget hash-key sub-key1
"value1"
127.0.0.1:6379> hgetall hash-key
1) "sub-key1"
2) "value1"
3) "sub-key3"
4) "value3"
# hset：设置键值对
# hget：获取指定键的值
# hgetall：获取散列中所有的键值对
# hdel：删除指定键的值

List（列表）

Redis列表是简单的字符串列表，按照插入顺序排序，我们可以往列表的左边或右边添加元素。

127.0.0.1:6379> rpush list-key v1
(integer) 1
127.0.0.1:6379> rpush list-key v2
(integer) 2
127.0.0.1:6379> rpush list-key v1
(integer) 3
127.0.0.1:6379> lrange list-key 0 -1
1) "v1"
2) "v2"
3) "v1"
127.0.0.1:6379> lindex list-key 1
"v2"
127.0.0.1:6379> lpop list
(nil)
127.0.0.1:6379> lpop list-key
"v1"
127.0.0.1:6379> lrange list-key 0 -1
1) "v2"
2) "v1"
# lpush：从列表开头插入新元素,返回插入新元素后列表的长度
# lpop：从列表开头弹出一个元素，返回被弹出的元素，类型是字符串
# lrange：获取指定范围内键的元素值,0 -1 是表示从第一个元素到倒数最后一个元素，如果改为-2则表示是到倒数第二个元素
# lindex：获取列表指定位置的元素

我们可以看出list就是一个简单的字符串集合，和Python中的list相差不多，区别就是这里的list存放的是字符串，list内的元素是可重复的。

set（集合）

Redis的set是字符串类型的无序集合。集合通过哈希表实现的，因此添加、删除、查找的复杂度都是O(1)。

127.0.0.1:6379> sadd k1 v1
(integer) 1
127.0.0.1:6379> sadd k1 v2
(integer) 1
127.0.0.1:6379> sadd k1 v3
(integer) 1
127.0.0.1:6379> sadd k1 v1
(integer) 0
127.0.0.1:6379> smembers k1
1) "v3"
2) "v2"
3) "v1"
127.0.0.1:6379> sismember k1 k4
(integer) 0
127.0.0.1:6379> sismember k1 v1
(integer) 1
127.0.0.1:6379> srem k1 v2
(integer) 1
127.0.0.1:6379> srem k1 v2
(integer) 0
127.0.0.1:6379> smembers k1
1) "v3"
2) "v1"
# sadd：往集合中添加元素，元素也可以为字符串，浮点型，添加成功则返回1，否则为0，已添加过的元素添加不了，会返回0。
# smembers：显示集合中所有的元素，如果元素很多速度很慢，so别乱用
# sismember：查找集合中指定元素是否存在，如果存在返回1否则返回0
# srem：移除集合中指定元素

Redis的set与python中的set还是有点区别的。Redis的set是一个key对应着多个字符串类型的value，也就是一个字符串类型的集合，但是和Redis的list不同的是set的字符串集合元素不能重复，但是list可以。

Zset（有序集合）

Redis zset和set一样都是字符串类型元素的集合，并且集合内的元素不能重复。

不同的是zset每个元素都会关联一个double类型的分数。Redis通过分数来为集合中的成员进行从小到大的排序。

zset的元素是惟一的，但是分数（score）却可以重复。

127.0.0.1:6379> zadd zset-key 728 member1
(integer) 1
127.0.0.1:6379> zadd zset-key 982 member0
(integer) 1
127.0.0.1:6379> zadd zset-key 982 member0
(integer) 0
127.0.0.1:6379> zrange zset-key 0 -1 withscores
1) "member1"
2) "728"
3) "member0"
4) "982"
127.0.0.1:6379> zrangebyscore zset-key 0 800 withscores
1) "member1"
2) "728"
127.0.0.1:6379> zrem zset-key member1
(integer) 1
127.0.0.1:6379> zrem zset-key member1
(integer) 0
127.0.0.1:6379> zrange zset-key 0 -1 withscores
1) "member0"
2) "982"
# zadd：将一个带有给定分值的成员添加到有序集合里面
# zrange：根据元素在有序列表中所处的位置，从有序集合中获取多个元素，如果没有带‘withscores’,获取的都是集合的成员
# zrangebyscore：获取有序集合在给定分制范围内的所有元素
# zrem：如果给定成员存在与有序集合中，那么移除这个元素

zset是按照分数的大小来排序的。

总结

特性场景：

string（字符串）：二进制安全可以包含任何数据，如jpg图片或序列化的对象，一个键最大能存储512M。
hash（哈希）：键值对集合，即python的dict类型适合存储对象，并且可以像数据库中的update 一样只修改某一项属性值存储、读取、修改用户属性List（列表）双向链表增删快，提供了操作某一段元素的 API1、最新消息排行等功能（朋友圈的时间线）
set（集合）：消息队列Set哈希表实现，元素不能重复添加删除查找的复杂度都是 O(1);为集合提供了求交集、并集、差集等操作共同好友；利用唯一性，统计访问网站的所有独立 ip；好友推荐时，根据 tag 求交集，大于某个阈值就可以推荐Zset（有序集合）将 Set 中的元素增加一个权重参数 score，元素按 score 有序排列数据插入集合时，已经进行天然排序排行榜；带权重的消息队列

Redis命令

启动 redis 客户端，打开终端并输入命令 redis-cli。该命令会连接本地的 redis 服务。

C:\Users\Administrator>redis-cli
127.0.0.1:6379> PING
PONG
# 连接到本地的 redis 服务并执行 PING 命令，该命令用于检测 redis 服务是否启动。
# Redis Ping 命令使用客户端向 Redis 服务器发送一个 PING ，如果服务器运作正常的话，会返回一个 PONG ,否则返回一个连接错误

如果需要在远程 redis 服务上执行命令，同样我们使用的也是 redis-cli 命令。
```
C:\Users\Administrator>redis-cli -h host -p port -a password
```
有时候会有中文乱码。要在 redis-cli 后面加上 --raw
```
redis-cli --raw
```

发布订阅

一般不用Redis做消息发布订阅。

Redis发布订阅（pub/sub）是一种消息通信模式：发送者（pub）发送消息、订阅者（sub）接收消息。

Redis客户端可以订阅任意数量的频道。

下图展示了频道channel1以及订阅这频道的三个客户端——client1、client5、client2之间的关系：

当有新消息通过PUBLISH命令发送给频道channel1时，这个消息就会被发送给订阅它的三个客户端：

以下实例演示了发布订阅是如何工作的。实例中创建了订阅频道名为redisChat

127.0.0.1:6379> SUBSCRIBE redisChat
Reading messages... (press Ctrl-C to quit)
1) "subscribe"
2) "redisChat"
3) (integer) 1

现在，我们先重新开启个Redis客户端，然后再同一个频道redisChat发布两次消息，订阅者就能收到消息。

# 另一个客户端
127.0.0.1:6379> PUBLISH redisChat "send message"
(integer) 1
127.0.0.1:6379> PUBLISH redisChat "hello world"
(integer) 1
# 订阅者的客户端显示如下
1) "message"
2) "redisChat"
3) "send message"
1) "message"
2) "redisChat"
3) "hello world"
# SUBSCRIBE：订阅给定的一个或多个频道的信息。
# UNSUBSCRIBE:退订给定的频道。
# PUBLISH:将消息发送到指定的频道
# PSUBSCRIBE:订阅一个或多个符合给定模式的频道

事务

Redis事务一次可以执行多条命令，服务器在执行命令期间，不会执行其他客户端的命令请求。

事务中的多条命令被一次性发送给服务器，而不是一条条地发送，这种方式被称为流水线，它可以减少客户端与服务端之间的网络通信次数，从而提升性能。

Redis最简单的事务实现方式是使用MULTI和EXEC命令将事务操作包围起来。

Redis事务可以一次执行多条命令，并且带有以下三个重要的保证：

批量操作在发送EXEC命令前被放入队列缓存
收到EXEC命令后进入事务执行，事务中任意命令执行失败，其余的命令依然被执行。
在事务执行过程，其他客户端提交的命令请求不会插入到事务执行命令序列中。

一个事务从开始到执行会经历以下三个阶段：

开始事务
命令入队
执行事务

以下是一个事务的例子，它先以 MULTI 开始一个事务，然后将多个命令入队到事务中，最后由 EXEC 命令触发事务，一并执行事务中的所有命令：

redis 127.0.0.1:6379> MULTI
OK
redis 127.0.0.1:6379> SET book-name "Mastering C++ in 21 days"
QUEUED
redis 127.0.0.1:6379> GET book-name
QUEUED
redis 127.0.0.1:6379> SADD tag "C++" "Programming" "Mastering Series"
QUEUED
redis 127.0.0.1:6379> SMEMBERS tag
QUEUED
redis 127.0.0.1:6379> EXEC
1) OK
2) "Mastering C++ in 21 days"
3) (integer) 3
4) 1) "Mastering Series"
 2) "C++"
 3) "Programming"

单个 Redis 命令的执行是原子性的，但 Redis 没有在事务上增加任何维持原子性的机制，所以 Redis 事务的执行并不是原子性的。

事务可以理解为一个打包的批量执行脚本，但批量指令并非原子化的操作，中间某条指令的失败不会导致前面已做指令的回滚，也不会造成后续的指令不做。

redis 127.0.0.1:7000> multi
OK
redis 127.0.0.1:7000> set a aaa
QUEUED
redis 127.0.0.1:7000> set b bbb
QUEUED
redis 127.0.0.1:7000> set c ccc
QUEUED
redis 127.0.0.1:7000> exec
1) OK
2) OK
3) OK
# redis事务命令
# DISCARD:取消事务，放弃执行事务块内的所有命令
# EXEC：执行所有事务块内的命令
# MULTI：标记一个事务块的开始
# UNWATCH：取消WATCH命令对所有key的监视
WATCH key[key...]：监视一个或多个key，如果在事务执行之前这个(或这些) key 被其他命令所改动，那么事务将被打断。

如果在 set b bbb 处失败，set a 已成功不会回滚，set c 还会继续执行。

持久化

Redis是内存型数据库，为了保证数据在断电后不会丢失，需要将内存中的数据持久化到硬盘中。

RDB持久化

将某个时间点的所有数据都存放到硬盘上。可以将快照复制到其他服务器从而创建具有相同数据的服务器副本。如果系统发生故障，将会丢失最后一次创建快照之后的数据。如果数据量大，保存快照的时间会很长。

AOF持久化

将写命令添加到 AOF 文件（append only file）末尾。

使用 AOF 持久化需要设置同步选项，从而确保写命令同步到磁盘文件上的时机。这是因为对文件进行写入并不会马上将内容同步到磁盘上，而是先存储到缓冲区，然后由操作系统决定什么时候同步到磁盘。

选项同步频率always每个写命令都同步eyerysec每秒同步一次no让操作系统来决定何时同步

always 选项会严重减低服务器的性能

everysec 选项比较合适，可以保证系统崩溃时只会丢失一秒左右的数据，并且 Redis 每秒执行一次同步对服务器几乎没有任何影响。

no 选项并不能给服务器性能带来多大的提升，而且会增加系统崩溃时数据丢失的数量。

随着服务器写请求的增多，AOF 文件会越来越大。Redis 提供了一种将 AOF 重写的特性，能够去除 AOF 文件中的冗余写命令。

复制

通过使用 slaveof host port 命令来让一个服务器成为另一个服务器的从服务器。一个从服务器只能有一个主服务器，并且不支持主主复制。

连接过程

主服务器创建快照文件，即 RDB 文件，发送给从服务器，并在发送期间使用缓冲区记录执行的写命令。快照文件发送完毕之后，开始像从服务器发送存储在缓冲区的写命令。

从服务器丢弃所有旧数据，载入主服务器发来的快照文件，之后从服务器开始接受主服务器发来的写命令。

主服务器每执行一次写命令，就向从服务器发送相同的写命令。

主从链

随着负载不断上升，主服务器无法很快的更新所有从服务器，或者重新连接和重新同步从服务器将导致系统超载。为了解决这个问题，可以创建一个中间层来分担主服务器的复制工作。中间层的服务器是最上层服务器的从服务器，又是最下层服务器的主服务器。

哨兵

Sentinel（哨兵）可以监听集群中的服务器，并在主服务器进入下线状态时，自动从从服务器中选举处新的主服务器。

分片

分片是将数据划分为多个部分的方法，可以将数据存储到多台机器里面，这种方法在解决某些问题时可以获得线性级别的性能提升。

假设有 4 个 Redis 实例 R0, R1, R2, R3, 还有很多表示用户的键 user:1, user:2, … , 有不同的方式来选择一个指定的键存储在哪个实例中。

最简单的是范围分片，例如用户 id 从 0 ~ 1000 的存储到实例 R0 中，用户 id 从 1001 ~ 2000 的存储到实例 R1中，等等。但是这样需要维护一张映射范围表，维护操作代价高。

还有一种是哈希分片。使用 CRC32 哈希函数将键转换为一个数字，再对实例数量求模就能知道存储的实例。

根据执行分片的位置，可以分为三种分片方式：

客户端分片：客户端使用一致性哈希等算法决定应当分布到哪个节点。
代理分片：将客户端的请求发送到代理上，由代理转发到正确的节点上。
服务器分片：Redis Cluster。

pycharm操作Redis

连接数据库

import redis
# 方式一
# r = redis.Redis(host="localhost", port=6379, db=0)
# 方式二
r = redis.StrictRedis(host='localhost', port=6379, db=0)
value = r.get('a')
print(value)  # b'aaa'

事务操作

import redis

pool = redis.ConnectionPool(db=0, decode_responses=True)
r = redis.Redis(connection_pool=pool)
# 创建管道
pipe = r.pipeline()

try:
    # 记录操作
    pipe.set('name', 'allen')
    pipe.set('age', 20)
    # 执行操作（一次性将命令发送到服务器）
    pipe.execute()

except Exception as e:
    pipe.reset()
print(r.get('age'))

设置单个key值，获取单个key值

import redis

r = redis.Redis(host='localhost', port=6379, db=0, decode_responses=True)
r.set('name', 'tank')
print(r.get('name'))

来源：https://www.cnblogs.com/daizongqi/p/11679475.html

标签

Redis

数据库事务

服务器类型

客户端服务器