Redis 实战 —— 01. Redis 数据结构简介

一些数据库和缓存服务器的特性和功能 P4

名称	类型	数据存储选项	查询类型	附加功能
Redis	使用内存存储（in-memory）的非关系数据库	字符串、列表、哈希表、集合、有序集合	每种数据类型都有自己的专属命令，另外还有批量操作（bulk operation）和不完全（partial）的事务支持	发布与订阅，主从复制（master/slave replication）
memcached	使用内存存储的键值缓存	键值之间的映射	增删改查以及其他几个命令	为提升性能而设的多线程服务器
MySQL	关系数据库	每个数据库可以包含多个表，每个表可以包含多个行；可以处理多个表的试图（view）；支持空间（spatial）和第三方扩展	增删改查、函数、存储过程	支持ACID性质（需要使用InnoDB），主从复制和主主复制（master/master replication）
PostgreSQL	关系数据库	每个数据库可以包含多个表，每个表可以包含多个行；可以处理多个表的试图；支持空间和第三方扩展；支持可定制类型	增删改查、内置函数、自定义的存储过程	支持ACID性质，主从复制，由第三方支持的多主复制（multi-master replication）
MongoDB	使用硬盘存储（on-disk）的非关系文档存储	每个数据库可以包含多个表，每个表可以包含多个无schema (schema-less) 的 BSON 文档（Binary JSON，类似json的一种二进制格式）	增删改查	支持 map-reduce 操作，主从复制，分片，空间索引（spatial index）

持久化方式 P4

• RDB(redis database)：以快照的形式将数据持久化到磁盘
• AOF(append only file)：以日志的形式记录每个操作，将Redis执行过的所有指令全部记录下来（读操作不记录），只许追加文件但不可以修改文件，Redis启动时会读取AOF配置文件重构数据

Redis 的 5 种结构 P6

结构类型	结构存储的值	结构的读写能力
STRING	可以是字符串、整数或者浮点数	对整个字符串或者字符串的其中一部分执行操作；对整数和浮点数执行自增（increment）或者自减（decrement）
LIST	一个链表，链表上的每个节点都包含了一个字符串	从链表的两端推入或者弹出元素；根据偏移量对链表进行修剪（trim）；读取单个或者多个元素；根据值查找或者移除元素
HASH	包含键值对的无序哈希表	添加、获取、移除单个键值对；获取所有键值对
SET	包含字符串的无序收集器（unordered collection），并且被包含的每个字符串都是独一无二、各不相同的	添加、获取、移除单个元素；检查一个元素是否存在于集合中；计算交集、并集、差集；从集合里面随机获取元素
ZSET（有序集合）	字符串成员（member）与浮点数分值（score）之间的有序映射，元素的排列顺序由分值的大小决定	添加、获取、移除单个元素；根据分值范围（range）或者成员来获取元素

STRING 基础命令 P8

STRING 存储键值对，值既可以是字符串，又可以是数值（数值支持自增和自减）

package main

import (
    "fmt"
    "github.com/gomodule/redigo/redis"
    "time"
)

func main() {
    // 获取连接
    conn, err := redis.Dial("tcp", "127.0.0.1:6379")
    if err != nil {
        // 连接失败，则打印错误信息，并退出
        fmt.Println(err)
        return
    }

    // 如果连接成功，则延迟执行 关闭
    defer conn.Close()

    executeStringCommand(conn)
}

// 执行 STRING 的相关命令
func executeStringCommand(conn redis.Conn) {
    fmt.Println("--------- executeStringCommand start ---------")

    // 设置 键为 hello 的值为 world，永久有效
    result, err := conn.Do("SET", "hello", "world")
    handleResult(result, err)

    // 获取 键为 hello 的剩余时间（TTL -> 秒，PTTL -> 毫秒）
    result, err = redis.Int(conn.Do("TTL", "hello"))
    handleResult(result, err)

    // 获取 键为 hello 的值
    result, err = redis.String(conn.Do("GET", "hello"))
    handleResult(result, err)

    // 设置 键为 hello 的值为 world，有效时间为 1000ms（EX -> 秒，PX -> 毫秒；不可同时使用）
    result, err = conn.Do("SET", "hello", "world", "EX", "1")
    handleResult(result, err)

    // 获取 键为 hello 的剩余时间（TTL -> 秒，PTTL -> 毫秒）
    result, err = redis.Int(conn.Do("PTTL", "hello"))
    handleResult(result, err)

    time.Sleep(time.Second * 2)
    // 获取 键为 hello 的剩余时间（TTL -> 秒，PTTL -> 毫秒）
    result, err = redis.Int(conn.Do("PTTL", "hello"))
    handleResult(result, err)

    // 设置 键为 hello 的值为 world，永久有效（NX -> 键不存在时，才进行设置操作；XX -> 键已经存在时，才进行设置操作）
    result, err = conn.Do("SET", "hello", "world!", "XX")
    handleResult(result, err)

    // 设置 键为 hello 的值为 world，永久有效（NX -> 键不存在时，才进行设置操作；XX -> 键已经存在时，才进行设置操作）
    result, err = conn.Do("SET", "hello", "world!", "NX")
    handleResult(result, err)

    // 删除 键为 hello 的值（可以用于所有类型）
    result, err = conn.Do("DEL", "hello")
    handleResult(result, err)

    // 获取 键为 hello 的值
    result, err = redis.String(conn.Do("GET", "hello"))
    handleResult(result, err)

    fmt.Println("--------- executeStringCommand end ---------")
}

// 处理操作 redis 的结果
func handleResult(result interface{}, err error) {
    if err != nil {
        fmt.Println("ERROR: ", err)
        return
    }
    fmt.Println(result)
}

LIST 基础命令 P9

// 执行 LIST 的相关命令
func executeListCommand(conn redis.Conn) {
    fmt.Println("--------- executeListCommand start ---------")

    // 在 list 列表的 右端 插入值
    result, err := conn.Do("RPUSH", "list", "item-1", "item-2")
    handleResult(result, err)

    // 在 list 列表的 左端 插入值
    result, err = conn.Do("LPUSH", "list", "item-3", "item-4")
    handleResult(result, err)

    // 在 list 列表中 以左端为头获取 [1, 3] 范围内的所有值（结束索引为 -1 表示可以取出到列表尾的所有元素；没有 RRANGE 命令）
    result, err = redis.Strings(conn.Do("LRANGE", "list", "1", "-1"))
    handleResult(result, err)

    // 在 list 列表中 以左端为头获取 下标为 0（没有 RINDEX 命令）
    result, err = redis.String(conn.Do("LINDEX", "list", "0"))
    handleResult(result, err)

    // 在 list 列表的 右端 弹出并一个值
    result, err = redis.String(conn.Do("RPOP", "list"))
    handleResult(result, err)

    // 在 list 列表的 左端 弹出并一个值
    result, err = redis.String(conn.Do("LPOP", "list"))
    handleResult(result, err)

    // 删除 键为 list 的值（可以用于所有类型）
    result, err = conn.Do("DEL", "list")
    handleResult(result, err)

    // 在 list 列表中 以左端为头获取所有值
    result, err = redis.Strings(conn.Do("LRANGE", "list", "0", "-1"))
    handleResult(result, err)

    fmt.Println("--------- executeListCommand end ---------")
}

SET 基础命令 P10

// 执行 SET 的相关命令
func executeSetCommand(conn redis.Conn) {
    fmt.Println("--------- executeSetCommand start ---------")

    // 在 set 集合中 添加值
    result, err := conn.Do("SADD", "set", "item-1", "item-2", "item-2", "item-3", "item-4")
    handleResult(result, err)

    // 从 set 集合中 删除值
    result, err = conn.Do("SREM", "set", "item-2", "item-3")
    handleResult(result, err)

    // 判断一个值是否在 set 集合中
    result, err = redis.Bool(conn.Do("SISMEMBER", "set", "item-2"))
    handleResult(result, err)

    // 获取 set 集合中 的所有值（不推荐使用，大 key 执行慢）
    result, err = redis.Strings(conn.Do("SMEMBERS", "set"))
    handleResult(result, err)

    // 删除 键为 set 的值（可以用于所有类型）
    result, err = conn.Do("DEL", "set")
    handleResult(result, err)

    fmt.Println("--------- executeSetCommand end ---------")
}

HASH 基础命令 P11

HASH 可以存储多个键值对之间的映射，和 STRING 一样，存储的值既可以是字符串，又可以是数值（数值支持自增和自减）

// 执行 HASH 的相关命令
func executeHashCommand(conn redis.Conn) {
    fmt.Println("--------- executeHashCommand start ---------")

    // 在 hash 哈希表中 添加一个键值对
    result, err := conn.Do("HSET", "hash", "key-1", "item-1")
    handleResult(result, err)

    // 在 hash 哈希表中 添加多个键值对
    result, err = conn.Do("HMSET", "hash", "key-2", "item-2", "key-3", "item-3", "key-4", "item-4", "key-5", "item-5")
    handleResult(result, err)

    // 从 hash 哈希表中 获取键 为 key-1 的值
    result, err = redis.String(conn.Do("HGET", "hash", "key-1"))
    handleResult(result, err)

    // 从 hash 哈希表中 获取多个键值对（返回值的顺序和传入参数的顺序一样）
    result, err = redis.Strings(conn.Do("HMGET", "hash", "key-2", "key-1"))
    handleResult(result, err)

    // 删除 hash 哈希表中键为 key-1 的值（可以用于所有类型）
    result, err = conn.Do("HDEL", "hash", "key-1")
    handleResult(result, err)

    // 从 hash 哈希表中 获取所有键值对（不推荐使用，大 key 执行慢）
    result, err = redis.StringMap(conn.Do("HGETALL", "hash"))
    handleResult(result, err)

    // 删除 键为 hash 的值（可以用于所有类型）
    result, err = conn.Do("DEL", "hash")
    handleResult(result, err)

    fmt.Println("--------- executeHashCommand end ---------")
}

ZSET 基础命令 P12

ZSET 和 HASH 一样，都用于存储键值对。ZSET 的键被称为成员（member），每个成员都是各不相同的；值被称为分值（score），分值必须为浮点数。ZSET 是 Redis 里面唯一一个既可以根据成员访问元素，又可以根据分值以及分值的排列顺序来访问元素的结构。

// 执行 ZSET 的相关命令
func executeZsetCommand(conn redis.Conn) {
    fmt.Println("--------- executeZsetCommand start ---------")

    // 在 zset 有序集合中 添加值
    result, err := conn.Do("ZADD", "zset", "0", "item-1", "12.34", "item-1", "-12.34", "item-2", "56.78", "item-3", "-56.78", "item-4", "-56.78", "item-5")
    handleResult(result, err)

    // 从 zset 有序集合中 删除值
    result, err = conn.Do("ZREM", "zset", "item-2", "item-3")
    handleResult(result, err)

    // 获取 zset 有序集合中 指定范围的值（结束索引为 -1 表示从开始索引到结束的所有值）
    // 成员的位置按 score 值递增（从小到大）来排序，相同 score 值的成员按字典序升序来排列
    // WITHSCORES 选项可以让成员和它的 score 值一并返回，返回列表格式：value1,score1, ..., valueN,scoreN
    result, err = redis.Strings(conn.Do("ZRANGE", "zset", "0", "-1", "WITHSCORES"))
    handleResult(result, err)

    // 获取 zset 有序集合中 指定范围的值（结束索引为 -1 表示从开始索引到结束的所有值）
    // 成员的位置按 score 值递减（从小到大）来排序，相同 score 值的成员按字典序降序来排列
    // WITHSCORES 选项可以让成员和它的 score 值一并返回，返回列表格式：value1,score1, ..., valueN,scoreN
    result, err = redis.Strings(conn.Do("ZREVRANGE", "zset", "0", "-1", "WITHSCORES"))
    handleResult(result, err)

    // 获取 zset 有序集合中 score 在指定范围 min, max 的值（-inf：负无穷，+inf 正无穷；默认为闭区间，数字前加 ( 表示开区间）
    // 成员的位置按 score 值递增（从小到大）来排序，相同 score 值的成员按字典序升序来排列
    // WITHSCORES 选项可以让成员和它的 score 值一并返回，返回列表格式：value1,score1, ..., valueN,scoreN
    // LIMIT offset, count 和 SQL 中 limit 一样，指定返回结果的数量及区间
    result, err = redis.Strings(conn.Do("ZRANGEBYSCORE", "zset", "-inf", "+inf", "WITHSCORES"))
    handleResult(result, err)

    // 获取 zset 有序集合中 score 在指定范围 max, min 的值（-inf：负无穷，+inf 正无穷；默认为闭区间，数字前加 ( 表示开区间）
    // 成员的位置按 score 值递减（从小到大）来排序，相同 score 值的成员按字典序降序来排列
    // WITHSCORES 选项可以让成员和它的 score 值一并返回，返回列表格式：value1,score1, ..., valueN,scoreN
    // LIMIT offset, count 和 SQL 中 limit 一样，指定返回结果的数量及区间
    result, err = redis.Strings(conn.Do("ZREVRANGEBYSCORE", "zset", "(12.34", "-inf", "WITHSCORES", "LIMIT", "1", "1"))
    handleResult(result, err)

    // 删除 键为 zset 的值（可以用于所有类型）
    result, err = conn.Do("DEL", "zset")
    handleResult(result, err)

    fmt.Println("--------- executeZsetCommand end ---------")
}

所思所想

• 慢即是快，不要眼高手低。刚开始看了几页就感觉太基础了，平常都有使用，不想再继续读下去。转念一想，以前只知道部分指令的作用，没有实践，这次可以好好操作一下。为了提高自己的兴趣，决定用 Golang 来调用进行实践，一举两得。

本文首发于公众号：满赋诸机（点击查看原文） 开源在 GitHub ：reading-notes/redis-in-action