乐趣区

关于redis集群:Redis-实战-01-Redis-数据结构简介

jiezi

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

退出移动版