manfuzhuji

一些数据库和缓存服务器的特性和功能 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

相关文章: