Redis 的使用

Redis 的基本介绍

  1. Redis 是 NoSQL 数据库，不是传统的关系型数据库。
  2. Redis: Remote Dictionary Server(远程字典服务器)，Redis 性能非常高，单机能够达到 15W qps，通常适合做缓存，也可以持久化。

  3. Redis 是完全开源免费的、高性能的(key/value)分布式内存数据库，基于内存运行并支持持久化的 NoSQL 数据库，是最热门的 NoSql 数据库之一，也称为数据结构服务器。

    Redis 的安装和基本使用

  4. 下载后直接解压就有 Redis 的服务器端程序(redis-server.exe)和客户端程序(redis-cli.exe)，直接双击即可运行，并不需要安装。

    Redis 的启动

  5. 启动 Redis 的服务器端程序(redis-server.exe)，直接双击即可运行。

    Redis 操作的三种方式

  6. 使用 telnet 操作 Redis

  7. 使用 redis-cli 操作 Redis

  8. Golang 操作 Redis

    Redis 的命令

  9. Redis 命令一览：http://redisdoc.com

    Redis 的快速入门

  10. 说明：Redis 安装好后，默认有 16 个数据库，初始默认使用 0 号库，编号是 0…15 。

  11. 基本命令

    1. (1) 添加 key-value [set]
    2. set key1 hello
    3. (2) 查看当前 redis 的所有 key [keys *]
    4. keys *
    5. (3) 获取 key 对应的值 [get key]
    6. get key1
    7. (4) 切换 redis 数据库 [select index]
    8. select 1
    9. (5) 如何查看当前数据库的 key-value [dbsize]
    10. dasize 1
    11. (6) 清空当前数据库的 key-value 和清空所有数据库的 key-value [flushdb flushall]

    Redis 数据类型和 CRUD

    Redis 的五大数据类型

  12. Redis 的五大数据类型是：String(字符串)、Hash(哈希)、List(列表)、Set(集合)和Zset(sorted set：有序集合)。

    Redis CRUD 操作

    Redis 中对 String 的基本使用

    String 介绍

  13. String 是 redis 最基本的类型，一个 key 对应一个 value。

  14. String 类型是二进制安全的。除普通的字符串外，也可以存放图片等数据。

  15. redis 中字符串 value 最大是 512M

    Redis 操作 String

  16. 举例

    1. set address beijing

  17. String 字符串的 CRUD 操作

  1. set(如果存在就相当于修改，不存在就是添加)/get/del

  1. Setex(Set with expire)键 秒 值

    1. setex key seconds value

  2. mset(同时设置一个或多个 key-value 对)

    1. mset key value key1 value1 ...

  3. mget(一次性返回多个 key 的值)

    1. mget key key1

    Redis 中对 Hash 的基本使用

    Hash 介绍

  4. Redis Hash 是一个键值对集合。

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

    Redis 操作 Hash

  6. 举例

    1. hset user1 name "smith"
    2. hset user1 age 30
    3. hset user1 job "golang coder"

  7. hget

    1. hget user1 name

  8. hgetall

    1. hgetall user1

  9. hdel

    1. hdel user1

  10. hmset(一次性设置多个 field 的值)

    1. hmset user1 name "smith" age 30 job "golang coder"

  11. hmget(一次性返回多个 field 的值)

    1. hmget user1 name age

  12. hlen(统计一个 hash 有多少个元素)

    1. hlen user1

  13. hexits key field(查看哈希表 key 中，给定域 field 是否存在)

    1. hexits user1 name

    Redis 中对 List 的基本使用

    List 介绍

  14. 列表是简单的字符串列表，按照插入顺序排序。你可以添加一个元素到列表的头部(左边)或者尾部(右边)

  15. List 本质是一个链表，List 的元素是有序的，元素的值可以重复。

    Redis 操作 List

  16. 举例

    1. lpush city beijing shanghai shengzhen

  17. lrang

    1. lrange city 0 -1

  18. List 的 CRUD 操作

    1. lpush/rpush/lrange/lpop/rpop/del

  19. 举例

    1. lpush herolist aaa bbb ccc
    2. lrange herolist 0 -1
    3. 取出的数据：ccc bbb aaa
    4. rpush herolist ddd eee
    5. lrange herolist 0 -1
    6. 取出的数据：ccc bbb aaa ddd eee
    7. lpop herolist
    8. 弹出的数据：ccc
    9. lrange herolist 0 -1
    10. 取出的数据：bbb aaa ddd eee
    11. rpop herolist
    12. 弹出的数据：eee
    13. 取出的数据：bbb aaa ddd
    14. del herolist
    15. 删除 herolist

    List 使用细节和注意事项

  20. index ，按照索引下标获得元素(从左到右，编号从0开始)

  21. llen key
    • 返回列表 key 的长度，如果 key 不存在，则 key 被解释为一个空列表，返回 0。

  22. List 的其他说明

    • List 数据，可以从左或者从右插入添加。
    • 如果值全移除，对应的键也就消失了。

      Redis 中对 Set 的基本使用

      Set 介绍

  23. Redis 的 Set 是 String 类型的无序集合。

  24. Set 底层是 Hash Table 数据结构，Set 也是存放很多字符串元素，字符串元素是无序的，而且元素的值不能重复。

    Redis 操作 Set

  25. 举例

    1. sadd emails sgg@sohu.com tom@sohu.com

  26. smembers

    1. smembers emails

  27. Set 的 CRUD 操作

    1. sadd/smembers(取出所有值)/sismembers(判断值是否是成员)/srem(删除指定值)

    Golang 操作 Redis

    安装第三方开源 Redis 库

  28. 使用第三方开源的 Redis 库：github.com/garyburd/redigo/redis

  29. 在使用 Redis 前，先安装第三方 Redis 库，在 GOPATH 路径下执行指令

    1. D:\goproject>go get github.com/gaurd/redigo/redis

  30. 特别说明：在安装 Redis 库前，确保已经安装并配置了 Git，因为是从 github 下载安装 Redis 库，需要使用 Git。如果没有安装配置过 Git。

    Set/Get 接口

  31. 说明：通过 Golang 添加和获取 key-value。 ```go package main

import ( “fmt” “github.com/gomodule/redigo/redis” )

func main() { // 通过 go 向 redis 写入数据和读取数据 // 1. 连接到 redis conn, err := redis.Dial(“tcp”, “127.0.0.1:6379”) if err != nil { fmt.Println(“redis.Dial err =”, err) return } fmt.Println(“Connect successful…”, conn)

  1. defer conn.Close() //关闭
  3. // 2. 通过 go 向 redis 写入数据 string [key-value]
  4. _, err = conn.Do("Set", "name", "Tom")
  5. if err != nil {
  6.     fmt.Println("Set err =", err)
  7.     return
  8. }
  9. fmt.Println("Insert data successful...")
  11. // 3. 通过 go 向 redis 读取数据 string [key-value]
  12. str, err := redis.String(conn.Do("Get", "name"))
  13. if err != nil {
  14.     fmt.Println("Get err =", err)
  15.     return
  16. }
  18. fmt.Println("Get data successful...", str)

}

  1. <a name="28497aac"></a>
  2. ### 操作 Hash
  4. 1. 说明：通过 Golang 对 Redis 操作 Hash 数据类型。
  5. 1. 举例
  6. ```go
  7. package main
  9. import (
  10.     "fmt"
  11.     "github.com/gomodule/redigo/redis"
  12. )
  14. func main() {
  15.     // 通过 go 向 redis 写入数据和读取数据
  16.     // 1. 链接到 redis
  17.     conn, err := redis.Dial("tcp", "127.0.0.1:6379")
  18.     if err != nil {
  19.         fmt.Println("redis.Dial err =", err)
  20.         return
  21.     }
  22.     fmt.Println("Connect successful...", conn)
  24.     defer conn.Close() //关闭
  26.     // 2. 通过 go 向 redis 写入数据
  27.     _, err = conn.Do("HSet", "user1", "name", "John")
  28.     if err != nil {
  29.         fmt.Println("HSet err =", err)
  30.         return
  31.     }
  33.     fmt.Println("Insert data successful...")
  35.     _, err = conn.Do("HSet", "user1", "age", 18)
  36.     if err != nil {
  37.         fmt.Println("HSet err =", err)
  38.         return
  39.     }
  41.     fmt.Println("Insert data successful...")
  43.     // 3. 通过 go 向 redis 读取数据
  44.     str, err := redis.String(conn.Do("HGet", "user1", "name"))
  45.     if err != nil {
  46.         fmt.Println("HGet err =", err)
  47.         return
  48.     }
  49.     fmt.Println("Get data successful...", str)
  51.     age, err := redis.Int(conn.Do("HGet", "user1", "age"))
  52.     if err != nil {
  53.         fmt.Println("HGet err =", err)
  54.         return
  55.     }
  57.     fmt.Println("Get data successful...", age)
  58. }
  1. 批量操作 hash ```go package main

import ( “fmt” “github.com/gomodule/redigo/redis” )

func main() { // 通过 go 向 redis 写入数据和读取数据 // 1. 链接到 redis conn, err := redis.Dial(“tcp”, “127.0.0.1:6379”) if err != nil { fmt.Println(“redis.Dial err =”, err) return } fmt.Println(“Connect successful…”, conn)

  1. defer conn.Close() //关闭
  3. // 2. 通过 go 向 redis 写入数据
  4. _, err = conn.Do("HMSet", "user2", "name", "Tom", "age", 19)
  5. if err != nil {
  6.     fmt.Println("HMSet err =", err)
  7.     return
  8. }
  10. fmt.Println("Insert data successful...")
  13. // 3. 通过 go 向 redis 读取数据
  14. str, err := redis.Strings(conn.Do("HMGet", "user2", "name", "age"))
  15. if err != nil {
  16.     fmt.Println("HMGet err =", err)
  17.     return
  18. }
  20. // 4. 遍历取值
  21. for index, value := range str {
  22.     fmt.Printf("str[%d] = %v \n", index, value)
  23. }
  25. fmt.Println("Get data successful...")

}

  1. <a name="f58907b9"></a>
  2. ### 批量 Set/Get 数据
  4. 1. 说明：通过 Golang 对 Redis 操作，一次操作可以 Set/Get 多个 key-value 数据。
  5. 1. 举例
  6. ```go
  7. _, err = conn.Do("Mset", "name", "尚硅谷", "address", "北京昌平")
  8. str, err := redis.Strings(conn.Do("Mget", "name", "adress"))
  10. for _, value := range str {
  11.     fmt.Println(value)
  12. }

给数据设置有效时间

  1. 说明：通过 Golang 对 Redis 操作，给 key-value 设置有效时间。

  2. 举例

    1. _, err = conn.Do("expire", "name", 10)

    操作 List

  3. 说明：通过 Golang 对 Redis 操作 List 数据类型。

  4. 举例

    1. _, err = conn.Do("lpush", "herolist", "no1:宋江", 30, "no2:卢俊义", 28)
    2. str, err := redis.String(conn.DO("rpop", "herolist"))

    Redis 连接池

  5. 说明：通过 Golang 对 Redis 操作，还可以通过 Redis 连接池。

  6. 连接池流程如下：
    • 事先初始化一定数量的连接，放入连接池
    • 当 Go 需要操作 Redis 时，直接从 Redis 连接池取出连接即可。
    • 这样可以节省临时获取 Redis 连接时间，从而提高效率。
  7. 举例 ```go package main

import ( “fmt” “github.com/gomodule/redigo/redis” )

//定义一个全局的 pool var pool *redis.Pool

//当启动程序时，就初始化连接池 func init() { pool = &redis.Pool{ MaxIdle: 8, // 最大空闲连接数 MaxActive: 0, // 表示和数据库的最大连接数，0 表示没有限制 IdleTimeout: 100, // 最大空闲时间 Dial: func() (conn redis.Conn, e error) { // 初始化连接代码 return redis.Dial(“tcp”, “localhost:6379”) }, } }

func main() { // 先从 pool 取出一个连接 conn := pool.Get() defer conn.Close() // 延时关闭

  1. // 插入数据
  2. _, err := conn.Do("Set", "name", "Tom")
  3. if err != nil {
  4.     fmt.Println("Set err =", err)
  5.     return
  6. }
  7. fmt.Println("Insert data successful...")
  9. // 取出数据
  10. str, err := redis.String(conn.Do("get", "name"))
  11. if err != nil {
  12.     fmt.Println("Get err =", err)
  13.     return
  14. }
  15. fmt.Println("Get data successful...")
  16. fmt.Println("str =", str)
  18. //defer pool.Close()

} ```

课程来源