一些数据库和缓存服务器的特性和功能 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 来调用进行实践，一举两得。