redis

package
v0.13.3 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Nov 2, 2025 License: MIT Imports: 11 Imported by: 1

README

Redis 组件

Redis 组件提供完整的 Redis 客户端功能,包括连接管理、数据操作、缓存管理和发布订阅等功能。

概述

Redis 组件是基于 go-redis 库封装的 Redis 客户端组件,提供简单易用的 API 接口,支持字符串、列表、集合、哈希表等多种数据类型的操作,同时提供缓存管理功能,支持键前缀、过期时间等配置。

功能特性

  • 连接管理:自动连接池管理,支持连接测试和健康检查
  • 数据类型支持:字符串、列表、集合、哈希表、有序集合等
  • 缓存管理:提供缓存管理器,支持键前缀、过期时间配置
  • 发布订阅:支持消息发布和订阅功能
  • 事务支持:支持 Redis 事务操作
  • Lua 脚本:支持执行 Lua 脚本
  • 错误处理:完善的错误处理机制
  • 配置管理:支持默认值检查和配置验证

快速开始

安装
go get github.com/jcbowen/jcbaseGo/component/redis
基本使用示例
package main

import (
    "fmt"
    "github.com/jcbowen/jcbaseGo"
    "github.com/jcbowen/jcbaseGo/component/redis"
    "time"
)

func main() {
    // Redis 配置
    config := jcbaseGo.RedisStruct{
        Host:     "localhost",
        Port:     "6379",
        Password: "",
        Db:       "0",
    }

    // 创建 Redis 实例
    redisInstance := redis.New(config)

    // 测试连接
    pong, err := redisInstance.Ping()
    if err != nil {
        panic(fmt.Sprintf("Redis 连接失败: %v", err))
    }
    fmt.Printf("Redis 连接成功: %s\n", pong)

    // 设置键值
    err = redisInstance.Set("test_key", "hello world", time.Hour)
    if err != nil {
        panic(fmt.Sprintf("设置键值失败: %v", err))
    }

    // 获取键值
    value, err := redisInstance.GetString("test_key")
    if err != nil {
        panic(fmt.Sprintf("获取键值失败: %v", err))
    }
    fmt.Printf("获取的值: %s\n", value)

    // 删除键值
    err = redisInstance.Del("test_key")
    if err != nil {
        panic(fmt.Sprintf("删除键值失败: %v", err))
    }
    fmt.Println("键值删除成功")
}
使用缓存管理器示例
package main

import (
    "fmt"
    "github.com/jcbowen/jcbaseGo"
    "github.com/jcbowen/jcbaseGo/component/redis"
    "time"
)

func main() {
    // Redis 配置
    config := jcbaseGo.RedisStruct{
        Host:     "localhost",
        Port:     "6379",
        Password: "",
        Db:       "0",
    }

    // 创建 Redis 实例
    redisInstance := redis.New(config)

    // 创建缓存管理器
    cache, err := redis.NewCache(redisInstance, 
        redis.WithPrefix("myapp"),
        redis.WithExpire(time.Hour),
    )
    if err != nil {
        panic(fmt.Sprintf("创建缓存管理器失败: %v", err))
    }

    // 设置缓存
    user := map[string]interface{}{
        "id":   1,
        "name": "张三",
        "age":  30,
    }
    
    err = cache.Set("user:1", user, 2*time.Hour)
    if err != nil {
        panic(fmt.Sprintf("设置缓存失败: %v", err))
    }

    // 获取缓存
    var cachedUser map[string]interface{}
    err = cache.GetStruct("user:1", &cachedUser)
    if err != nil {
        panic(fmt.Sprintf("获取缓存失败: %v", err))
    }
    fmt.Printf("缓存用户: %+v\n", cachedUser)

    // 检查缓存是否存在
    exists, err := cache.Exists("user:1")
    if err != nil {
        panic(fmt.Sprintf("检查缓存失败: %v", err))
    }
    fmt.Printf("缓存存在: %v\n", exists)

    // 获取缓存统计信息
    stats, err := cache.GetStats()
    if err != nil {
        panic(fmt.Sprintf("获取统计信息失败: %v", err))
    }
    fmt.Printf("缓存统计: %+v\n", stats)
}
列表操作示例
package main

import (
    "fmt"
    "github.com/jcbowen/jcbaseGo"
    "github.com/jcbowen/jcbaseGo/component/redis"
)

func main() {
    config := jcbaseGo.RedisStruct{
        Host: "localhost",
        Port: "6379",
    }

    redisInstance := redis.New(config)

    // 向列表左端插入元素
    err := redisInstance.LPush("mylist", "item1", "item2")
    if err != nil {
        panic(fmt.Sprintf("LPush 失败: %v", err))
    }

    // 向列表右端插入元素
    err = redisInstance.RPush("mylist", "item3", "item4")
    if err != nil {
        panic(fmt.Sprintf("RPush 失败: %v", err))
    }

    // 获取列表范围
    items, err := redisInstance.LRange("mylist", 0, -1)
    if err != nil {
        panic(fmt.Sprintf("LRange 失败: %v", err))
    }
    fmt.Printf("列表内容: %v\n", items)

    // 获取列表长度
    length, err := redisInstance.LLen("mylist")
    if err != nil {
        panic(fmt.Sprintf("LLen 失败: %v", err))
    }
    fmt.Printf("列表长度: %d\n", length)

    // 从列表左端弹出元素
    item, err := redisInstance.LPop("mylist")
    if err != nil {
        panic(fmt.Sprintf("LPop 失败: %v", err))
    }
    fmt.Printf("弹出的元素: %s\n", item)
}
哈希表操作示例
package main

import (
    "fmt"
    "github.com/jcbowen/jcbaseGo"
    "github.com/jcbowen/jcbaseGo/component/redis"
)

func main() {
    config := jcbaseGo.RedisStruct{
        Host: "localhost",
        Port: "6379",
    }

    redisInstance := redis.New(config)

    // 设置哈希表字段
    err := redisInstance.HSet("user:profile", "name", "李四")
    if err != nil {
        panic(fmt.Sprintf("HSet 失败: %v", err))
    }

    err = redisInstance.HSet("user:profile", "age", "25")
    if err != nil {
        panic(fmt.Sprintf("HSet 失败: %v", err))
    }

    // 获取哈希表字段
    name, err := redisInstance.HGet("user:profile", "name")
    if err != nil {
        panic(fmt.Sprintf("HGet 失败: %v", err))
    }
    fmt.Printf("用户名: %s\n", name)

    // 获取所有哈希表字段
    profile, err := redisInstance.HGetAll("user:profile")
    if err != nil {
        panic(fmt.Sprintf("HGetAll 失败: %v", err))
    }
    fmt.Printf("用户资料: %+v\n", profile)

    // 检查字段是否存在
    exists, err := redisInstance.HExists("user:profile", "name")
    if err != nil {
        panic(fmt.Sprintf("HExists 失败: %v", err))
    }
    fmt.Printf("字段存在: %v\n", exists)
}
发布订阅示例
package main

import (
    "fmt"
    "github.com/jcbowen/jcbaseGo"
    "github.com/jcbowen/jcbaseGo/component/redis"
    "time"
)

func main() {
    config := jcbaseGo.RedisStruct{
        Host: "localhost",
        Port: "6379",
    }

    redisInstance := redis.New(config)

    // 启动订阅者协程
    go func() {
        pubsub, err := redisInstance.Subscribe("mychannel")
        if err != nil {
            panic(fmt.Sprintf("订阅失败: %v", err))
        }
        defer pubsub.Close()

        // 接收消息
        for {
            msg, err := pubsub.ReceiveMessage(redisInstance.Context)
            if err != nil {
                fmt.Printf("接收消息失败: %v\n", err)
                break
            }
            fmt.Printf("收到消息: 频道=%s, 内容=%s\n", msg.Channel, msg.Payload)
        }
    }()

    // 等待订阅者准备
    time.Sleep(100 * time.Millisecond)

    // 发布消息
    for i := 1; i <= 3; i++ {
        message := fmt.Sprintf("消息 %d", i)
        err := redisInstance.Publish("mychannel", message)
        if err != nil {
            panic(fmt.Sprintf("发布消息失败: %v", err))
        }
        fmt.Printf("发布消息: %s\n", message)
        time.Sleep(500 * time.Millisecond)
    }

    time.Sleep(1 * time.Second)
}

详细配置

RedisStruct 配置

RedisStruct 是 Redis 连接的基础配置结构体:

type RedisStruct struct {
    Host     string `json:"host" default:"127.0.0.1"`     // Redis 主机地址
    Port     string `json:"port" default:"6379"`         // Redis 端口
    Password string `json:"password" default:""`         // Redis 密码
    Db       string `json:"db" default:"0"`             // Redis 数据库编号
}
Cache 配置选项

Cache 管理器支持以下配置选项:

// 设置缓存键前缀
cache, err := redis.NewCache(redisInstance, 
    redis.WithPrefix("myapp"),
)

// 设置默认过期时间
cache, err := redis.NewCache(redisInstance,
    redis.WithExpire(time.Hour),
)

// 同时设置前缀和过期时间
cache, err := redis.NewCache(redisInstance,
    redis.WithPrefix("myapp"),
    redis.WithExpire(30*time.Minute),
)

高级功能

使用 Lua 脚本
package main

import (
    "fmt"
    "github.com/jcbowen/jcbaseGo"
    "github.com/jcbowen/jcbaseGo/component/redis"
)

func main() {
    config := jcbaseGo.RedisStruct{
        Host: "localhost",
        Port: "6379",
    }

    redisInstance := redis.New(config)

    // 定义 Lua 脚本
    script := `
        local key = KEYS[1]
        local increment = ARGV[1]
        local current = redis.call('GET', key) or 0
        local new_value = current + increment
        redis.call('SET', key, new_value)
        return new_value
    `

    // 执行 Lua 脚本
    result, err := redisInstance.Eval(script, []string{"counter"}, 5)
    if err != nil {
        panic(fmt.Sprintf("执行 Lua 脚本失败: %v", err))
    }

    fmt.Printf("Lua 脚本执行结果: %v\n", result)
}
批量操作示例
package main

import (
    "fmt"
    "github.com/jcbowen/jcbaseGo"
    "github.com/jcbowen/jcbaseGo/component/redis"
    "time"
)

func main() {
    config := jcbaseGo.RedisStruct{
        Host: "localhost",
        Port: "6379",
    }

    redisInstance := redis.New(config)

    // 批量设置多个键值
    keys := []string{"key1", "key2", "key3"}
    values := []string{"value1", "value2", "value3"}

    for i, key := range keys {
        err := redisInstance.Set(key, values[i], time.Hour)
        if err != nil {
            fmt.Printf("设置 %s 失败: %v\n", key, err)
        }
    }

    // 批量删除多个键
    err := redisInstance.Del(keys...)
    if err != nil {
        panic(fmt.Sprintf("批量删除失败: %v", err))
    }

    fmt.Println("批量操作完成")
}
缓存管理器高级用法
package main

import (
    "fmt"
    "github.com/jcbowen/jcbaseGo"
    "github.com/jcbowen/jcbaseGo/component/redis"
    "time"
)

func main() {
    config := jcbaseGo.RedisStruct{
        Host: "localhost",
        Port: "6379",
    }

    redisInstance := redis.New(config)

    cache, err := redis.NewCache(redisInstance,
        redis.WithPrefix("myapp"),
        redis.WithExpire(time.Hour),
    )
    if err != nil {
        panic(fmt.Sprintf("创建缓存管理器失败: %v", err))
    }

    // 获取所有匹配模式的键
    keys, err := cache.GetKeys("user:*")
    if err != nil {
        panic(fmt.Sprintf("获取键列表失败: %v", err))
    }
    fmt.Printf("匹配的键: %v\n", keys)

    // 清除所有缓存
    err = cache.ClearAll()
    if err != nil {
        panic(fmt.Sprintf("清除缓存失败: %v", err))
    }
    fmt.Println("缓存清除完成")

    // 获取缓存统计信息
    stats, err := cache.GetStats()
    if err != nil {
        panic(fmt.Sprintf("获取统计信息失败: %v", err))
    }
    fmt.Printf("缓存统计: %+v\n", stats)
}

错误处理

错误检查方法
// 检查键是否存在
exists, err := redisInstance.Exists("mykey")
if err != nil {
    // 处理错误
    fmt.Printf("检查键存在失败: %v\n", err)
} else {
    fmt.Printf("键存在: %v\n", exists)
}

// 获取键值,提供默认值
value, err := redisInstance.GetString("mykey", "default_value")
if err != nil {
    fmt.Printf("获取键值失败: %v\n", err)
} else {
    fmt.Printf("键值: %s\n", value)
}
常见错误类型
  • 连接错误:无法连接到 Redis 服务器
  • 认证错误:密码认证失败
  • 键不存在:尝试获取不存在的键
  • 类型错误:操作类型不匹配
  • 超时错误:操作超时

性能优化建议

  1. 连接池配置:合理配置连接池大小
  2. 批量操作:使用批量操作减少网络往返
  3. 管道技术:对于多个操作使用管道
  4. 键设计:合理设计键名,避免过长的键名
  5. 过期时间:设置合理的过期时间,避免内存泄漏

安全考虑

  • 使用密码认证保护 Redis 实例
  • 配置防火墙限制访问来源
  • 定期更新 Redis 版本
  • 监控 Redis 内存使用情况
  • 使用不同的数据库编号隔离不同应用

API 参考

Instance 结构体

Redis 实例的主要结构体

字段:

  • Context context.Context - 上下文
  • Conf jcbaseGo.RedisStruct - 配置信息
  • Client *redis.Client - Redis 客户端

主要方法:

  • New(conf jcbaseGo.RedisStruct) *Instance - 创建 Redis 实例
  • Ping() (string, error) - 测试连接
  • Set(key string, value interface{}, args ...time.Duration) error - 设置键值
  • GetString(key string, args ...string) (string, error) - 获取字符串值
  • GetStruct(key string, value interface{}, args ...interface{}) error - 获取结构体值
  • Del(key ...string) error - 删除键
  • Exists(key string) (bool, error) - 检查键是否存在
  • Keys(pattern string) ([]string, error) - 获取匹配的键
  • LPush(key string, values ...interface{}) error - 列表左端插入
  • RPush(key string, values ...interface{}) error - 列表右端插入
  • LRange(key string, start, stop int64) ([]string, error) - 获取列表范围
  • LLen(key string) (int64, error) - 获取列表长度
  • LPop(key string) (string, error) - 列表左端弹出
  • RPop(key string) (string, error) - 列表右端弹出
  • SAdd(key string, members ...interface{}) (int64, error) - 集合添加成员
  • SRem(key string, members ...interface{}) (int64, error) - 集合移除成员
  • SMembers(key string) ([]string, error) - 获取集合成员
  • SIsMember(key string, member interface{}) (bool, error) - 检查集合成员
  • HSet(key, field string, value interface{}) error - 哈希表设置字段
  • HGet(key, field string) (string, error) - 哈希表获取字段
  • HGetAll(key string) (map[string]string, error) - 获取所有哈希字段
  • HExists(key, field string) (bool, error) - 检查哈希字段存在
  • Incr(key string) (int64, error) - 增加计数器
  • Decr(key string) (int64, error) - 减少计数器
  • Expire(key string, expiration time.Duration) (bool, error) - 设置过期时间
  • TTL(key string) (time.Duration, error) - 获取剩余过期时间
  • Publish(channel string, message interface{}) error - 发布消息
  • Subscribe(channels ...string) (*redis.PubSub, error) - 订阅频道
  • Eval(script string, keys []string, args ...interface{}) (interface{}, error) - 执行 Lua 脚本
Cache 结构体

缓存管理器结构体

字段:

  • redis *Instance - Redis 实例
  • Prefix string - 键前缀
  • Expire time.Duration - 默认过期时间

主要方法:

  • NewCache(redis *Instance, opts ...CacheOption) (*Cache, error) - 创建缓存管理器
  • Set(key string, value interface{}, expire ...time.Duration) error - 设置缓存
  • GetString(key string, defaultValue ...string) (string, error) - 获取字符串缓存
  • GetStruct(key string, value interface{}, defaultValue ...interface{}) error - 获取结构体缓存
  • Del(key string) error - 删除缓存
  • Exists(key string) (bool, error) - 检查缓存存在
  • ClearAll() error - 清除所有缓存
  • GetKeys(pattern string) ([]string, error) - 获取匹配的键
  • GetStats() (map[string]interface{}, error) - 获取统计信息
配置选项函数
  • WithPrefix(prefix string) CacheOption - 设置键前缀
  • WithExpire(expire time.Duration) CacheOption - 设置默认过期时间

版本历史

  • v1.0.0:初始版本,包含基本的 Redis 操作和缓存管理功能
  • 支持多种数据类型的操作
  • 提供缓存管理器功能

贡献指南

欢迎提交 Issue 和 Pull Request 来改进 Redis 组件。

许可证

Redis 组件遵循 MIT 许可证。

Documentation

Index

Constants

View Source
const Nil = redis.Nil

Variables

This section is empty.

Functions

This section is empty.

Types

type Cache added in v0.10.2

type Cache struct {
	Prefix string        `json:"prefix" default:"jcbase"`
	Expire time.Duration `json:"expire" default:"0"`
	// contains filtered or unexported fields
}

Cache 缓存管理器结构体 提供基于Redis的缓存操作,支持键前缀、过期时间等配置

func NewCache

func NewCache(redis *Instance, opts ...CacheOption) (*Cache, error)

NewCache 创建一个新的缓存管理器实例 参数:

  • redis: Redis实例,不能为空
  • opts: 可选的配置选项

返回:

  • *Cache: 缓存管理器实例
  • error: 创建失败时的错误信息

func (*Cache) ClearAll added in v0.10.2

func (c *Cache) ClearAll() error

ClearAll 清除所有当前前缀的缓存 返回:

  • error: 清除失败时的错误信息

func (*Cache) Del added in v0.10.2

func (c *Cache) Del(key string) error

Del 删除缓存键 参数:

  • key: 要删除的缓存键

返回:

  • error: 删除失败时的错误信息

func (*Cache) Exists added in v0.10.2

func (c *Cache) Exists(key string) (bool, error)

Exists 检查缓存键是否存在 参数:

  • key: 要检查的缓存键

返回:

  • bool: 键存在返回true,否则返回false
  • error: 检查失败时的错误信息

func (*Cache) GetKeys added in v0.10.2

func (c *Cache) GetKeys(pattern string) ([]string, error)

GetKeys 获取所有匹配模式的缓存键 参数:

  • pattern: 键模式,支持通配符

返回:

  • []string: 匹配的键列表
  • error: 获取失败时的错误信息

func (*Cache) GetStats added in v0.10.2

func (c *Cache) GetStats() (map[string]interface{}, error)

GetStats 获取缓存统计信息 返回:

  • map[string]interface{}: 统计信息
  • error: 获取失败时的错误信息

func (*Cache) GetString added in v0.10.2

func (c *Cache) GetString(key string, defaultValue ...string) (string, error)

GetString 获取字符串类型的缓存值 参数:

  • key: 缓存键
  • defaultValue: 可选的默认值

返回:

  • string: 缓存值或默认值
  • error: 获取失败时的错误信息

func (*Cache) GetStruct added in v0.10.2

func (c *Cache) GetStruct(key string, value interface{}, defaultValue ...interface{}) error

GetStruct 获取结构体类型的缓存值 参数:

  • key: 缓存键
  • value: 指向目标结构体的指针
  • defaultValue: 可选的默认值

返回:

  • error: 获取失败时的错误信息

func (*Cache) Set added in v0.10.2

func (c *Cache) Set(key string, value interface{}, expire ...time.Duration) error

Set 设置缓存键值 参数:

  • key: 缓存键
  • value: 缓存值,会被序列化为JSON
  • expire: 过期时间,如果为0则使用默认过期时间

返回:

  • error: 设置失败时的错误信息

type CacheOption added in v0.10.2

type CacheOption func(*Cache)

CacheOption 缓存配置选项函数

func WithExpire added in v0.10.2

func WithExpire(expire time.Duration) CacheOption

WithExpire 设置默认过期时间

func WithPrefix added in v0.10.2

func WithPrefix(prefix string) CacheOption

WithPrefix 设置缓存键前缀

type Client

type Client = redis.Client

type Instance

type Instance struct {
	Context context.Context
	Conf    jcbaseGo.RedisStruct
	Client  *redis.Client
}

func New

func New(conf jcbaseGo.RedisStruct) *Instance

New 获取新的redis连接

func (*Instance) Decr

func (i *Instance) Decr(key string) (int64, error)

Decr 减少计数器的值。

func (*Instance) Del

func (i *Instance) Del(key ...string) error

Del 删除键值。

参数:

  • key (必需): 要删除的键值。

返回值:

  • error: 如果发生错误则返回相应的错误信息。

示例:

err := Del(key)
if err != nil {
    // 处理错误
}

func (*Instance) Eval

func (i *Instance) Eval(script string, keys []string, args ...interface{}) (interface{}, error)

Eval 执行 Lua 脚本。

func (*Instance) Exists

func (i *Instance) Exists(key string) (bool, error)

Exists 检查键值是否存在。

参数:

  • key (必需): 要检查的键值。

返回值:

  • bool: 如果键值存在则返回 true,否则返回 false。
  • error: 如果发生错误则返回相应的错误信息。

示例:

exists, err := Exists(key)
if err != nil {
    // 处理错误
}

func (*Instance) Expire

func (i *Instance) Expire(key string, expiration time.Duration) (bool, error)

Expire 设置键的过期时间。

func (*Instance) GetClient

func (i *Instance) GetClient() *redis.Client

GetClient 获取redis client

func (*Instance) GetString

func (i *Instance) GetString(key string, args ...string) (string, error)

GetString 根据键值,返回字符串值。 如果键不存在或发生错误,则返回默认值(如果提供)。

参数:

  • key (必需): 用于查找数据的字符串键值。
  • defaultValue (可选): 可选的默认值(字符串类型)。

返回值:

  • value: 获取到的字符串值,或者是默认值。
  • err: 如果发生错误则返回相应的错误信息。

示例:

value, err := GetString(key)
if err != nil {
    // 处理错误
} else {
    // 使用 value
}

value, err := GetString(key, "default")
if err != nil {
    // 处理错误
} else {
    // 使用 value
}

func (*Instance) GetStruct

func (i *Instance) GetStruct(key string, value interface{}, args ...interface{}) error

GetStruct 根据键值获取自定义结构体类型或 map 类型。 args 参数列表,支持以下格式:

  1. 提供 key 和 value(指向目标结构体的指针或 map 的指针):GetStruct(key, &value)
  2. 提供 key, value 和 defaultValue(默认值的任意类型):GetStruct(key, &value, defaultValue)

参数:

  • key (必需): 用于查找数据的字符串键值。
  • value (必需): 指向目标结构体的指针或 map 的指针,用于存储获取到的数据。
  • defaultValue (可选): 当获取数据失败时的默认值。

返回值:

  • error: 如果发生错误则返回相应的错误信息。

示例:

var value MyStruct
defaultValue := MyStruct{Field: "default"}
err := GetStruct(key, &value, defaultValue)
if err != nil {
    // 处理错误
} else {
    // 使用 value
}

func (*Instance) HExists

func (i *Instance) HExists(key, field string) (bool, error)

HExists 检查哈希表中是否存在指定字段。

func (*Instance) HGet

func (i *Instance) HGet(key, field string) (string, error)

HGet 获取哈希表中指定字段的值。

func (*Instance) HGetAll

func (i *Instance) HGetAll(key string) (map[string]string, error)

HGetAll 获取哈希表中所有字段和值。

func (*Instance) HSet

func (i *Instance) HSet(key, field string, value interface{}) error

HSet 设置哈希表中的字段值。

func (*Instance) Incr

func (i *Instance) Incr(key string) (int64, error)

Incr 增加计数器的值。

func (*Instance) Info

func (i *Instance) Info() (string, error)

Info 获取 Redis 服务器的信息。

func (*Instance) Keys

func (i *Instance) Keys(pattern string) ([]string, error)

Keys 获取键值列表。

参数:

  • pattern (必需): 匹配的键值模式。

返回值:

  • []string: 匹配到的键值列表。
  • error: 如果发生错误则返回相应的错误信息。

示例:

keys, err := Keys(pattern)
if err != nil {
    // 处理错误
}

func (*Instance) LLen

func (i *Instance) LLen(key string) (int64, error)

LLen 获取列表的长度。

func (*Instance) LPop

func (i *Instance) LPop(key string) (string, error)

LPop 从列表左端弹出一个元素。

func (*Instance) LPush

func (i *Instance) LPush(key string, values ...interface{}) error

LPush 向列表左端插入一个或多个元素。

func (*Instance) LRange

func (i *Instance) LRange(key string, start, stop int64) ([]string, error)

LRange 获取列表中指定范围的元素。

func (*Instance) Ping

func (i *Instance) Ping() (string, error)

Ping 检查与 Redis 服务器的连接是否正常。

func (*Instance) Publish

func (i *Instance) Publish(channel string, message interface{}) error

Publish 向指定频道发布消息。

func (*Instance) RPop

func (i *Instance) RPop(key string) (string, error)

RPop 从列表右端弹出一个元素。

func (*Instance) RPush

func (i *Instance) RPush(key string, values ...interface{}) error

RPush 向列表右端插入一个或多个元素。

func (*Instance) SAdd

func (i *Instance) SAdd(key string, members ...interface{}) (int64, error)

SAdd 向集合添加一个或多个成员。

func (*Instance) SIsMember

func (i *Instance) SIsMember(key string, member interface{}) (bool, error)

SIsMember 检查成员是否存在于集合中。

func (*Instance) SMembers

func (i *Instance) SMembers(key string) ([]string, error)

SMembers 获取集合中的所有成员。

func (*Instance) SRem

func (i *Instance) SRem(key string, members ...interface{}) (int64, error)

SRem 从集合中移除一个或多个成员。

func (*Instance) Set

func (i *Instance) Set(key string, value interface{}, args ...time.Duration) error

Set 设置键值。

参数:

  • key (必需): 要设置的键值。
  • value (必需): 要设置的值,将被转换为 JSON 格式保存。
  • expire (可选): 数据的过期时间,如果未设置则数据将永不过期。

返回值:

  • error: 如果发生错误则返回相应的错误信息。

示例:

err := Set(key, value, time.Hour)
if err != nil {
    // 处理错误
}

func (*Instance) Subscribe

func (i *Instance) Subscribe(channels ...string) (*redis.PubSub, error)

Subscribe 订阅指定频道接收消息。

func (*Instance) TTL

func (i *Instance) TTL(key string) (time.Duration, error)

TTL 获取键的剩余过期时间。

type StatusCmd

type StatusCmd = redis.StatusCmd

type StringCmd

type StringCmd = redis.StringCmd

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL