Go语言之 go-redis 基本使用Redis 介绍
Redis：https://redis.io/
Redis 中文网：https://www.redis.net.cn/
REmote DIctionary Server(Redis) 是一个由Salvatore Sanfilippo写的key-value存储系统。
Redis是一个开源的使用ANSI C语言编写、遵守BSD协议、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。
它通常被称为数据结构服务器，因为值（value）可以是 字符串(String), 哈希(Map), 列表(list), 集合(sets) 和 有序集合(sorted sets)等类型。
macOS 安装Redis
brew install redisWindows 安装 Redis
下载地址：https://github.com/dmajkic/redis/tags/
https://github.com/ServiceStack/redis-windows
https://github.com/microsoftarchive/redis/releases
go-redis 使用
安装 go-redis 库 https://github.com/redis/go-redis
go get github.com/redis/go-redis/v9Go-Redis 中文文档：https://redis.uptrace.dev/zh/
安装
go-redis 支持 2 个最新的 go 版本且依赖Go modules，如果 你还没有 go mod，你需要首先初始化:
go mod init github.com/my/repo安装 go-redis/v9 (支持所有的 redis 版本):
go get github.com/redis/go-redis/v9#连接到 Redis 服务器
连接到 Redis 服务器示例，更多配置参数，请参照 redis.Options:
import "github.com/redis/go-redis/v9"rdb := redis.NewClient(&redis.Options{Addr: "localhost:6379",Password: "", // 没有密码，默认值DB: 0, // 默认DB 0})同时也支持另外一种常见的连接字符串:
opt, err := redis.ParseURL("redis://:@localhost:6379/")if err != nil {panic(err)}rdb := redis.NewClient(opt)#使用 TLS
你需要手动设置 tls.Config，你可以在 这里 了解相关 tls.Config更多的配置信息：
rdb := redis.NewClient(&redis.Options{TLSConfig: &tls.Config{MinVersion: tls.VersionTLS12,ServerName: "you domain",//Certificates: []tls.Certificate{cert}},})如果你使用的是域名连接，且遇到了类似 x509: cannot validate certificate for xxx.xxx.xxx.xxx because it doesn't contain any IP SANs的错误 ，应该在 ServerName 中指定你的域名：更多详情请参考本链接
rdb := redis.NewClient(&redis.Options{TLSConfig: &tls.Config{MinVersion: tls.VersionTLS12,ServerName: "你的域名",},})#SSH 方式
使用 SSH 协议连接:
sshConfig := &ssh.ClientConfig{User: "root",Auth: []ssh.AuthMethod{ssh.Password("password")},HostKeyCallback: ssh.InsecureIgnoreHostKey(),Timeout: 15 * time.Second,}sshClient, err := ssh.Dial("tcp", "remoteIP:22", sshConfig)if err != nil {panic(err)}rdb := redis.NewClient(&redis.Options{Addr: net.JoinHostPort("127.0.0.1", "6379"),Dialer: func(ctx context.Context, network, addr string) (net.Conn, error) {return sshClient.Dial(network, addr)},// SSH不支持超时设置，在这里禁用ReadTimeout: -1,WriteTimeout: -1,})#dial tcp: i/o timeout
当你遇到 dial tcp: i/o timeout 错误时，表示 go-redis 无法连接 Redis 服务器，比如 redis 服务器没有 正常运行或监听了其他端口，以及可能被防火墙拦截等。你可以使用一些网络命令排查问题，例如 telnet:
telnet localhost 6379Trying 127.0.0.1...telnet: Unable to connect to remote host: Connection refused如果你使用 Docker、Kubernetes、Istio、Service Mesh、Sidecar 方式运行，应该确保服务在容器完全可用后启 动，你可以通过参考该地址、Readiness Gate、Istio holdApplicationUntilProxyStarts等。
Context 上下文
go-redis 支持 Context，你可以使用它控制 超时 或者传递一些数据, 也可以 监控 go-redis 性能。
ctx := context.Background()go-redis 实操 https://pkg.go.dev/github.com/go-redis/redis安装
Code/go/redis_demo via 🐹 v1.20.3 via 🅒 base ➜ go get github.com/redis/go-redis/v9go: downloading github.com/redis/go-redis/v9 v9.0.5go: downloading github.com/redis/go-redis v6.15.9+incompatiblego: downloading github.com/cespare/xxhash/v2 v2.2.0go: downloading github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5fgo: added github.com/cespare/xxhash/v2 v2.2.0go: added github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5fgo: added github.com/redis/go-redis/v9 v9.0.5Code/go/redis_demo via 🐹 v1.20.3 via 🅒 base took 2.4s ➜ 连接 Redis 服务器并初始化
package mainimport ("context""fmt""github.com/redis/go-redis/v9")// 声明一个全局的 rdb 变量var rdb *redis.Client// 初始化连接func initRedisClient() (err error) {// NewClient将客户端返回给Options指定的Redis Server。// Options保留设置以建立redis连接。rdb = redis.NewClient(&redis.Options{Addr: "localhost:6379",Password: "", // 没有密码，默认值DB: 0, // 默认DB 0 连接到服务器后要选择的数据库。PoolSize: 20, // 最大套接字连接数。 默认情况下，每个可用CPU有10个连接，由runtime.GOMAXPROCS报告。})// Background返回一个非空的Context。它永远不会被取消，没有值，也没有截止日期。// 它通常由main函数、初始化和测试使用，并作为传入请求的顶级上下文ctx := context.Background()_, err = rdb.Ping(ctx).Result()if err != nil {return err}return nil}func main() {if err := initRedisClient(); err != nil {fmt.Printf("initRedisClient failed: %v\n", err)return}fmt.Println("initRedisClient started successfully")defer rdb.Close() // Close 关闭客户端，释放所有打开的资源。关闭客户端是很少见的，因为客户端是长期存在的，并在许多例程之间共享。}运行
Code/go/redis_demo via 🐹 v1.20.3 via 🅒 base took 2.1s ➜ go run main.goinitRedisClient started successfullyCode/go/redis_demo via 🐹 v1.20.3 via 🅒 base ➜ 执行 Redis 命令
执行 Redis 命令:
val, err := rdb.Get(ctx, "key").Result()fmt.Println(val)你也可以分别访问值和错误：
get := rdb.Get(ctx, "key")fmt.Println(get.Val(), get.Err())执行尚不支持的命令
可以使用 Do() 方法执行尚不支持或者任意命令:
val, err := rdb.Do(ctx, "get", "key").Result()if err != nil {if err == redis.Nil {fmt.Println("key does not exists")return}panic(err)}fmt.Println(val.(string))Do() 方法返回 Cmd 类型，你可以使用它获取你 想要的类型：
// Text is a shortcut for get.Val().(string) with proper error handling.val, err := rdb.Do(ctx, "get", "key").Text()fmt.Println(val, err)方法列表:
s, err := cmd.Text()flag, err := cmd.Bool()num, err := cmd.Int()num, err := cmd.Int64()num, err := cmd.Uint64()num, err := cmd.Float32()num, err := cmd.Float64()ss, err := cmd.StringSlice()ns, err := cmd.Int64Slice()ns, err := cmd.Uint64Slice()fs, err := cmd.Float32Slice()fs, err := cmd.Float64Slice()bs, err := cmd.BoolSlice()#redis.Nil
redis.Nil 是一种特殊的错误，严格意义上来说它并不是错误，而是代表一种状态，例如你使用 Get 命令获取 key 的值，当 key 不存在时，返回 redis.Nil。在其他比如 BLPOP 、 ZSCORE 也有类似的响应，你需要区 分错误：
val, err := rdb.Get(ctx, "key").Result()switch {case err == redis.Nil:fmt.Println("key不存在")case err != nil:fmt.Println("错误", err)case val == "":fmt.Println("值是空字符串")}Conn
redis.Conn 是从连接池中取出的单个连接，除非你有特殊的需要，否则尽量不要使用它。你可以使用它向 redis 发送任何数据并读取 redis 的响应，当你使用完毕时，应该把它返回给 go-redis，否则连接池会永远丢失一个连 接。
cn := rdb.Conn(ctx)defer cn.Close()if err := cn.ClientSetName(ctx, "myclient").Err(); err != nil {panic(err)}name, err := cn.ClientGetName(ctx).Result()if err != nil {panic(err)}fmt.Println("client name", name)基本使用 执行命令
package mainimport ("context""fmt""github.com/redis/go-redis/v9""time")// 声明一个全局的 rdb 变量var rdb *redis.Client// 初始化连接func initRedisClient() (err error) {// NewClient将客户端返回给Options指定的Redis Server。// Options保留设置以建立redis连接。rdb = redis.NewClient(&redis.Options{Addr: "localhost:6379",Password: "", // 没有密码，默认值DB: 0, // 默认DB 0 连接到服务器后要选择的数据库。PoolSize: 20, // 最大套接字连接数。 默认情况下，每个可用CPU有10个连接，由runtime.GOMAXPROCS报告。})// Background返回一个非空的Context。它永远不会被取消，没有值，也没有截止日期。// 它通常由main函数、初始化和测试使用，并作为传入请求的顶级上下文ctx := context.Background()_, err = rdb.Ping(ctx).Result()if err != nil {return err}return nil}// doCommand go-redis基本使用示例func redisCommand() {ctx, cancel := context.WithTimeout(context.Background(), 500*time.Millisecond)defer cancel()// 获取Redis的“Get key”命令。它返回redis。当键不存在时出现Nil错误。val, err := rdb.Get(ctx, "key").Result()if err != nil {fmt.Printf("redis command failed: %v\n", err)}fmt.Printf("redis command get key %v\n", val)// 分别访问值和错误：get := rdb.Get(ctx, "key")fmt.Println("redis command get value: ", get.Val()) // 获取值fmt.Println("redis command get err: ", get.Err()) // 获取错误// 设置Redis ' Set key value [expiration] '命令。err = rdb.Set(ctx, "key", 10, time.Hour).Err()fmt.Printf("rdb set err: %v\n", err)// 获取Redis的“Get key”命令。它返回redis。当键不存在时出现Nil错误。value := rdb.Get(ctx, "key").Val()fmt.Printf("rdb get value: %v\n", value)}func main() {if err := initRedisClient(); err != nil {fmt.Printf("initRedisClient failed: %v\n", err)return}fmt.Println("initRedisClient started successfully")defer rdb.Close() // Close 关闭客户端，释放所有打开的资源。关闭客户端是很少见的，因为客户端是长期存在的，并在许多例程之间共享。redisCommand()}运行
Code/go/redis_demo via 🐹 v1.20.3 via 🅒 base ➜ go run main.goinitRedisClient started successfullyredis command failed: redis: nilredis command get key redis command get value: redis command get err: redis: nilrdb set err: rdb get value: 10Code/go/redis_demo via 🐹 v1.20.3 via 🅒 base ➜ Go Redis 配置Redis Client
type Options struct { // 连接网络类型，如: tcp、udp、unix等方式 // 如果为空默认tcp Network string // redis服务器地址，ip:port格式，比如：192.168.1.100:6379 // 默认为 :6379 Addr string // ClientName 是对网络连接设置一个名字，使用 "CLIENT LIST" 命令 // 可以查看redis服务器当前的网络连接列表 // 如果设置了ClientName，go-redis对每个连接调用 `CLIENT SETNAME ClientName` 命令 // 查看: https://redis.io/commands/client-setname/ // 默认为空，不设置客户端名称 ClientName string // 如果你想自定义连接网络的方式，可以自定义 `Dialer` 方法， // 如果不指定，将使用默认的方式进行网络连接 `redis.NewDialer` Dialer func(ctx context.Context, network, addr string) (net.Conn, error) // 建立了新连接时调用此函数 // 默认为nil OnConnect func(ctx context.Context, cn *Conn) error // 当redis服务器版本在6.0以上时，作为ACL认证信息配合密码一起使用， // ACL是redis 6.0以上版本提供的认证功能，6.0以下版本仅支持密码认证。 // 默认为空，不进行认证。 Username string // 当redis服务器版本在6.0以上时，作为ACL认证信息配合密码一起使用， // 当redis服务器版本在6.0以下时，仅作为密码认证。 // ACL是redis 6.0以上版本提供的认证功能，6.0以下版本仅支持密码认证。 // 默认为空，不进行认证。 Password string // 允许动态设置用户名和密码，go-redis在进行网络连接时会获取用户名和密码， // 这对一些认证鉴权有时效性的系统来说很有用，比如一些云服务商提供认证信息有效期为12小时。 // 默认为nil CredentialsProvider func() (username string, password string) // redis DB 数据库，默认为0 DB int // 命令最大重试次数， 默认为3 MaxRetries int // 每次重试最小间隔时间 // 默认 8 * time.Millisecond (8毫秒) ，设置-1为禁用 MinRetryBackoff time.Duration // 每次重试最大间隔时间 // 默认 512 * time.Millisecond (512毫秒) ，设置-1为禁用 MaxRetryBackoff time.Duration // 建立新网络连接时的超时时间 // 默认5秒 DialTimeout time.Duration // 从网络连接中读取数据超时时间，可能的值： // 0 - 默认值，3秒 // -1 - 无超时，无限期的阻塞 // -2 - 不进行超时设置，不调用 SetReadDeadline 方法 ReadTimeout time.Duration // 把数据写入网络连接的超时时间，可能的值： // 0 - 默认值，3秒 // -1 - 无超时，无限期的阻塞 // -2 - 不进行超时设置，不调用 SetWriteDeadline 方法 WriteTimeout time.Duration // 是否使用context.Context的上下文截止时间， // 有些情况下，context.Context的超时可能带来问题。 // 默认不使用 ContextTimeoutEnabled bool // 连接池的类型，有 LIFO 和 FIFO 两种模式， // PoolFIFO 为 false 时使用 LIFO 模式，为 true 使用 FIFO 模式。 // 当一个连接使用完毕时会把连接归还给连接池，连接池会把连接放入队尾， // LIFO 模式时，每次取空闲连接会从"队尾"取，就是刚放入队尾的空闲连接， // 也就是说 LIFO 每次使用的都是热连接，连接池有机会关闭"队头"的长期空闲连接， // 并且从概率上，刚放入的热连接健康状态会更好； // 而 FIFO 模式则相反，每次取空闲连接会从"队头"取，相比较于 LIFO 模式， // 会使整个连接池的连接使用更加平均，有点类似于负载均衡寻轮模式，会循环的使用 // 连接池的所有连接，如果你使用 go-redis 当做代理让后端 redis 节点负载更平均的话， // FIFO 模式对你很有用。 // 如果你不确定使用什么模式，请保持默认 PoolFIFO = false PoolFIFO bool // 连接池最大连接数量，注意：这里不包括 pub/sub，pub/sub 将使用独立的网络连接 // 默认为 10 * runtime.GOMAXPROCS PoolSize int // PoolTimeout 代表如果连接池所有连接都在使用中，等待获取连接时间，超时将返回错误 // 默认是 1秒+ReadTimeout PoolTimeout time.Duration // 连接池保持的最小空闲连接数，它受到PoolSize的限制 // 默认为0，不保持 MinIdleConns int // 连接池保持的最大空闲连接数，多余的空闲连接将被关闭 // 默认为0，不限制 MaxIdleConns int // ConnMaxIdleTime 是最大空闲时间，超过这个时间将被关闭。 // 如果 ConnMaxIdleTime <= 0，则连接不会因为空闲而被关闭。 // 默认值是30分钟，-1禁用 ConnMaxIdleTime time.Duration // ConnMaxLifetime 是一个连接的生存时间， // 和 ConnMaxIdleTime 不同，ConnMaxLifetime 表示连接最大的存活时间 // 如果 ConnMaxLifetime <= 0，则连接不会有使用时间限制 // 默认值为0，代表连接没有时间限制 ConnMaxLifetime time.Duration // 如果你的redis服务器需要TLS访问，可以在这里配置TLS证书等信息 // 如果配置了证书信息，go-redis将使用TLS发起连接， // 如果你自定义了 `Dialer` 方法，你需要自己实现网络连接 TLSConfig *tls.Config // 限流器的配置，参照 `Limiter` 接口 Limiter Limiter // 设置启用在副本节点只读查询，默认为false不启用 // 参照：https://redis.io/commands/readonly readOnly bool}获取 Redis 值 GET Key
package mainimport ("context""fmt""github.com/redis/go-redis/v9""time")// 声明一个全局的 rdb 变量var rdb *redis.Client// 初始化连接func initRedisClient() (err error) {// NewClient将客户端返回给Options指定的Redis Server。// Options保留设置以建立redis连接。rdb = redis.NewClient(&redis.Options{Addr: "localhost:6379",Password: "", // 没有密码，默认值DB: 0, // 默认DB 0 连接到服务器后要选择的数据库。PoolSize: 20, // 最大套接字连接数。 默认情况下，每个可用CPU有10个连接，由runtime.GOMAXPROCS报告。})// Background返回一个非空的Context。它永远不会被取消，没有值，也没有截止日期。// 它通常由main函数、初始化和测试使用，并作为传入请求的顶级上下文ctx := context.Background()_, err = rdb.Ping(ctx).Result()if err != nil {return err}return nil}func redisGetKey(key string) (string, error) {ctx, cancel := context.WithTimeout(context.Background(), 500*time.Millisecond)defer cancel()val, err := rdb.Get(ctx, key).Result()if err != nil {if err == redis.Nil {return "", nil// DeadlineExceeded是Context返回的错误。当上下文的截止日期过去时发生错误。} else if err == context.DeadlineExceeded {return "", fmt.Errorf("获取值超时")} else {return "", fmt.Errorf("获取值失败: %v", err)}}if val == "" {return "", nil}return val, nil}func main() {if err := initRedisClient(); err != nil {fmt.Printf("initRedisClient failed: %v\n", err)return}fmt.Println("initRedisClient started successfully")defer rdb.Close() // Close 关闭客户端，释放所有打开的资源。关闭客户端是很少见的，因为客户端是长期存在的，并在许多例程之间共享。//redisCommand()// get keyvalue, _ := redisGetKey("key")fmt.Printf("get key: %v\n", value)}运行
Code/go/redis_demo via 🐹 v1.20.3 via 🅒 base ➜ go run main.goinitRedisClient started successfullyget key: 10Code/go/redis_demo via 🐹 v1.20.3 via 🅒 base ➜ 设置值 SET
package mainimport ("context""fmt""github.com/redis/go-redis/v9""time")// 声明一个全局的 rdb 变量var rdb *redis.Client// 初始化连接func initRedisClient() (err error) {// NewClient将客户端返回给Options指定的Redis Server。// Options保留设置以建立redis连接。rdb = redis.NewClient(&redis.Options{Addr: "localhost:6379",Password: "", // 没有密码，默认值DB: 0, // 默认DB 0 连接到服务器后要选择的数据库。PoolSize: 20, // 最大套接字连接数。 默认情况下，每个可用CPU有10个连接，由runtime.GOMAXPROCS报告。})// Background返回一个非空的Context。它永远不会被取消，没有值，也没有截止日期。// 它通常由main函数、初始化和测试使用，并作为传入请求的顶级上下文ctx := context.Background()_, err = rdb.Ping(ctx).Result()if err != nil {return err}return nil}func redisSetKey(key string, val string) error {ctx, cancel := context.WithTimeout(context.Background(), 500*time.Millisecond)defer cancel()// 设置Redis ' Set key value [expiration] '命令。err := rdb.Set(ctx, key, val, time.Hour).Err()if err != nil {fmt.Printf("redis set failed, err: %v\n", err)return err}return nil}func main() {if err := initRedisClient(); err != nil {fmt.Printf("initRedisClient failed: %v\n", err)return}fmt.Println("initRedisClient started successfully")defer rdb.Close() // Close 关闭客户端，释放所有打开的资源。关闭客户端是很少见的，因为客户端是长期存在的，并在许多例程之间共享。// set valueerr := redisSetKey("name", "xia")if err != nil {fmt.Printf("redisSetKey failed: %v\n", err)return}fmt.Println("redisSetKey succeeded")}运行
Code/go/redis_demo via 🐹 v1.20.3 via 🅒 base ➜ go run main.goinitRedisClient started successfullyredisSetKey succeededHGetAll HSET
127.0.0.1:6379> hset user name "lixia"(integer) 1127.0.0.1:6379> hgetall user1) "name"2) "lixia"127.0.0.1:6379> hset user age 14(integer) 1127.0.0.1:6379> hgetall user1) "name"2) "lixia"3) "age"4) "14"127.0.0.1:6379>main.go
package mainimport ("context""fmt""github.com/redis/go-redis/v9""time")// 声明一个全局的 rdb 变量var rdb *redis.Client// 初始化连接func initRedisClient() (err error) {// NewClient将客户端返回给Options指定的Redis Server。// Options保留设置以建立redis连接。rdb = redis.NewClient(&redis.Options{Addr: "localhost:6379",Password: "", // 没有密码，默认值DB: 0, // 默认DB 0 连接到服务器后要选择的数据库。PoolSize: 20, // 最大套接字连接数。 默认情况下，每个可用CPU有10个连接，由runtime.GOMAXPROCS报告。})// Background返回一个非空的Context。它永远不会被取消，没有值，也没有截止日期。// 它通常由main函数、初始化和测试使用，并作为传入请求的顶级上下文ctx := context.Background()_, err = rdb.Ping(ctx).Result()if err != nil {return err}return nil}func hGetDemo(key string) (map[string]string, error) {ctx, cancel := context.WithTimeout(context.Background(), 500*time.Millisecond)defer cancel()val, err := rdb.HGetAll(ctx, key).Result()if err != nil {// redis.Nil// 其它错误fmt.Printf("hgetall failed, err: %v\n", err)return nil, err}return val, nil}func main() {if err := initRedisClient(); err != nil {fmt.Printf("initRedisClient failed: %v\n", err)return}fmt.Println("initRedisClient started successfully")defer rdb.Close() // Close 关闭客户端，释放所有打开的资源。关闭客户端是很少见的，因为客户端是长期存在的，并在许多例程之间共享。// hgetall()value, err := hGetDemo("user")if err != nil {fmt.Printf("hGetDem failed with error: %v\n", err)return}fmt.Printf("hgetall successful, value: %v\n", value)}运行
Code/go/redis_demo via 🐹 v1.20.3 via 🅒 base took 3.8s ➜ go run main.go initRedisClient started successfullyhgetall successful, value: map[age:14 name:lixia]Code/go/redis_demo via 🐹 v1.20.3 via 🅒 base ➜ HMGet HGet
package mainimport ("context""fmt""github.com/redis/go-redis/v9""time")// 声明一个全局的 rdb 变量var rdb *redis.Client// 初始化连接func initRedisClient() (err error) {// NewClient将客户端返回给Options指定的Redis Server。// Options保留设置以建立redis连接。rdb = redis.NewClient(&redis.Options{Addr: "localhost:6379",Password: "", // 没有密码，默认值DB: 0, // 默认DB 0 连接到服务器后要选择的数据库。PoolSize: 20, // 最大套接字连接数。 默认情况下，每个可用CPU有10个连接，由runtime.GOMAXPROCS报告。})// Background返回一个非空的Context。它永远不会被取消，没有值，也没有截止日期。// 它通常由main函数、初始化和测试使用，并作为传入请求的顶级上下文ctx := context.Background()_, err = rdb.Ping(ctx).Result()if err != nil {return err}return nil}func hMGetDemo() {ctx, cancel := context.WithTimeout(context.Background(), 500*time.Millisecond)defer cancel()val := rdb.HMGet(ctx, "user", "name", "age").Val()fmt.Printf("redis HMGet %v\n", val)value := rdb.HGet(ctx, "user", "age").Val()fmt.Printf("redis HGet value: %v\n", value)}func main() {if err := initRedisClient(); err != nil {fmt.Printf("initRedisClient failed: %v\n", err)return}fmt.Println("initRedisClient started successfully")defer rdb.Close() // Close 关闭客户端，释放所有打开的资源。关闭客户端是很少见的，因为客户端是长期存在的，并在许多例程之间共享。hMGetDemo()}运行
Code/go/redis_demo via 🐹 v1.20.3 via 🅒 base ➜ go run main.go initRedisClient started successfullyredis HMGet [lixia 14]redis HGet value: 14Code/go/redis_demo via 🐹 v1.20.3 via 🅒 base ➜ ZSET 使用
package mainimport ("context""fmt""github.com/redis/go-redis/v9""time")// 声明一个全局的 rdb 变量var rdb *redis.Client// 初始化连接func initRedisClient() (err error) {// NewClient将客户端返回给Options指定的Redis Server。// Options保留设置以建立redis连接。rdb = redis.NewClient(&redis.Options{Addr: "localhost:6379",Password: "", // 没有密码，默认值DB: 0, // 默认DB 0 连接到服务器后要选择的数据库。PoolSize: 20, // 最大套接字连接数。 默认情况下，每个可用CPU有10个连接，由runtime.GOMAXPROCS报告。})// Background返回一个非空的Context。它永远不会被取消，没有值，也没有截止日期。// 它通常由main函数、初始化和测试使用，并作为传入请求的顶级上下文ctx := context.Background()_, err = rdb.Ping(ctx).Result()if err != nil {return err}return nil}// zset Demo 操作 zset 示例func zSetDemo() {// keyzSetKey := "language_rank"// value Z表示有序集合的成员。languages := []redis.Z{{Score: 90.0, Member: "Golang"},{Score: 95.0, Member: "Python"},{Score: 97.0, Member: "Rust"},{Score: 99.0, Member: "C/C++"},{Score: 88.0, Member: "Java"},}// WithTimeout返回WithDeadline(parent, time.Now(). add (timeout))。ctx, cancel := context.WithTimeout(context.Background(), 500*time.Millisecond)defer cancel()// ZAdd Redis `ZADD key score member [score member ...]` command.num, err := rdb.ZAdd(ctx, zSetKey, languages...).Result()if err != nil {fmt.Printf("zadd failed, err:%v\n", err)return}fmt.Printf("zadd successful num: %v\n", num)// ZIncrBy 给某一个元素添加分数值 把Golang的分数加 10newScore, err := rdb.ZIncrBy(ctx, zSetKey, 10.0, "Golang").Result()if err != nil {fmt.Printf("ZIncrBy failed, err:%v\n", err)return}fmt.Printf("ZIncrBy success Golang's score is %f now.\n", newScore)// 取分数最高的3个 适用于 排行榜、充值榜...// ZRevRangeWithScores according to the Redis documentation, if member does not exist// in the sorted set or key does not exist, it will return a redis.Nil error.ret, err := rdb.ZRevRangeWithScores(ctx, zSetKey, 0, 2).Result()if err != nil {fmt.Printf("zRevRangeWithScores failed, err: %v\n", err)return}for _, z := range ret {fmt.Printf("z.Member: %v, z.Score: %v\n", z.Member, z.Score)}// 取95~100分的op := &redis.ZRangeBy{Min: "95",Max: "100",}ret, err = rdb.ZRangeByScoreWithScores(ctx, zSetKey, op).Result()if err != nil {fmt.Printf("zrangebyscore failed, err:%v\n", err)return}fmt.Printf("zrangebyscore returned %v\n", ret)for _, z := range ret {fmt.Printf("ZRangeByScoreWithScores success Member: %v, Score: %v\n", z.Member, z.Score)}}func main() {if err := initRedisClient(); err != nil {fmt.Printf("initRedisClient failed: %v\n", err)return}fmt.Println("initRedisClient started successfully")defer rdb.Close() // Close 关闭客户端，释放所有打开的资源。关闭客户端是很少见的，因为客户端是长期存在的，并在许多例程之间共享。zSetDemo()}运行
Code/go/redis_demo via 🐹 v1.20.3 via 🅒 base ➜ go run main.goinitRedisClient started successfullyzadd successful num: 5ZIncrBy success Golang's score is 100.000000 now.z.Member: Golang, z.Score: 100z.Member: C/C++, z.Score: 99z.Member: Rust, z.Score: 97zrangebyscore returned [{95 Python} {97 Rust} {99 C/C++} {100 Golang}]ZRangeByScoreWithScores success Member: Python, Score: 95ZRangeByScoreWithScores success Member: Rust, Score: 97ZRangeByScoreWithScores success Member: C/C++, Score: 99ZRangeByScoreWithScores success Member: Golang, Score: 100Code/go/redis_demo via 🐹 v1.20.3 via 🅒 base ➜ Redis 查询
127.0.0.1:6379> ZREVRANGE language_rank 0 21) "Golang"2) "C/C++"3) "Rust"127.0.0.1:6379> ZREVRANGE language_rank 0 2 withscores1) "Golang"2) "100"3) "C/C++"4) "99"5) "Rust"6) "97"127.0.0.1:6379> ZRANDMEMBER language_rank"Rust"127.0.0.1:6379> ZRANGE language_rank 0 21) "Java"2) "Python"3) "Rust"127.0.0.1:6379> ZRANGE language_rank 0 2 withscores1) "Java"2) "88"3) "Python"4) "95"5) "Rust"6) "97"127.0.0.1:6379> ZINCRBY language_rank 1 "Python""96"127.0.0.1:6379> ZRANGE language_rank 0 2 withscores1) "Java"2) "88"3) "Python"4) "96"5) "Rust"6) "97"127.0.0.1:6379>Scan 根据前缀查询 Key
package mainimport ("context""fmt""github.com/redis/go-redis/v9""time")// 声明一个全局的 rdb 变量var rdb *redis.Client// 初始化连接func initRedisClient() (err error) {// NewClient将客户端返回给Options指定的Redis Server。// Options保留设置以建立redis连接。rdb = redis.NewClient(&redis.Options{Addr: "localhost:6379",Password: "", // 没有密码，默认值DB: 0, // 默认DB 0 连接到服务器后要选择的数据库。PoolSize: 20, // 最大套接字连接数。 默认情况下，每个可用CPU有10个连接，由runtime.GOMAXPROCS报告。})// Background返回一个非空的Context。它永远不会被取消，没有值，也没有截止日期。// 它通常由main函数、初始化和测试使用，并作为传入请求的顶级上下文ctx := context.Background()_, err = rdb.Ping(ctx).Result()if err != nil {return err}return nil}func scanKeyDemo(match string) {// WithTimeout返回WithDeadline(parent, time.Now(). add (timeout))。ctx, cancel := context.WithTimeout(context.Background(), 500*time.Millisecond)defer cancel()// 根据前缀查询 Keyiter := rdb.Scan(ctx, 0, match, 0).Iterator()for iter.Next(ctx) {fmt.Printf("key value: %v\n", iter.Val())}if err := iter.Err(); err != nil {fmt.Printf("rdb scan failed, err: %v\n", err)return}}func main() {if err := initRedisClient(); err != nil {fmt.Printf("initRedisClient failed: %v\n", err)return}fmt.Println("initRedisClient started successfully")defer rdb.Close() // Close 关闭客户端，释放所有打开的资源。关闭客户端是很少见的，因为客户端是长期存在的，并在许多例程之间共享。scanKeyDemo("l*")}运行
Code/go/redis_demo via 🐹 v1.20.3 via 🅒 base ➜ go run main.goinitRedisClient started successfullykey value: language_rankCode/go/redis_demo via 🐹 v1.20.3 via 🅒 base ➜ 本文来自博客园，作者：寻月隐君，转载请注明原文链接：https://www.cnblogs.com/QiaoPengjun/p/17485294.html