redisTool

package module
v0.0.0-...-ea25f17 Latest Latest
Warning

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

 Go to latest Published: Dec 5, 2025 License: MIT Imports: 14 Imported by: 0

README

Redis Tool

一个功能丰富的 Redis 工具库，提供了对 Redis 各种数据结构的高级封装和实用功能。

特性

  • Builder 模式 - 灵活的配置和初始化
  • 类型安全 - 支持泛型，提供类型化的数据结构
  • 序列化 - 灵活的序列化机制，支持自定义序列化器
  • 数据结构 - List、Set、Map、ZSet 等常用数据结构
  • 高级功能 - Queue（队列）、Cache（缓存）、Lock（分布式锁）
  • 辅助工具 - 时间追踪、跨时间段检测等实用功能

安装

go get github.com/19z/redisTool

依赖包会自动安装：

  • github.com/gomodule/redigo - Redis 客户端
  • github.com/google/uuid - UUID 生成器
  • github.com/alicebob/miniredis/v2 - 测试用 Redis 模拟器

使用示例

1. 初始化 Redis 客户端
import "github.com/19z/redisTool"

func main() {
    redis := redisTool.Builder("127.0.0.1:6379", "password").
        Config(redisTool.Config{
            Prefix: "myproject:",
            MaxIdle: 10,
            MaxActive: 100,
            IdleTimeout: time.Second * 300,
        }).
        Build()
    
    // 设置为全局默认连接
    redisTool.SetDefaultConnection(redis)
}
2. 使用 List
// 创建列表
list := redis.NewList("mylist")
list.Push("item1")
list.Push("item2")

// 弹出元素
if value, ok := list.Pop(); ok {
    fmt.Println(value)
}

// 使用类型化列表
type Student struct {
    Name string
    Age  int
}

// 方式一：使用全局函数（需要先设置默认连接）
redisTool.SetDefaultConnection(redis)
typeList := redisTool.NewTypeList[Student]("students")
typeList.Push(Student{Name: "李四", Age: 20})

if student, ok := typeList.Pop(); ok {
    fmt.Println(student.Name, student.Age)
}

// 方式二：使用全局函数并指定连接
typeList2 := redisTool.NewTypeList[Student]("students2", redis)
typeList2.Push(Student{Name: "王五", Age: 22})
3. 使用 Set
set := redis.NewSet("myset")
set.Add("item1", "item2", "item3")
set.Remove("item1")

exists := set.Exists("item2")
fmt.Println("exists:", exists)

// 类型化 Set
typeSet := redisTool.NewTypeSet[Student]("students")
typeSet.Add(Student{Name: "张三", Age: 18})
4. 使用 Map
dict := redis.NewMap("mymap")
dict.Set("key1", "value1")

if value, ok := dict.Get("key1"); ok {
    fmt.Println(value)
}

// 类型化 Map
typeDict := redisTool.NewTypeMap[Student]("students")
typeDict.Set("student1", Student{Name: "张三", Age: 18})

// 数字型 Map
numberMap := redis.NewNumberMap("scores")
numberMap.Set("user1", 100)
numberMap.Increment("user1", 10)
5. 使用 ZSet
zset := redisTool.NewTypeZSet[Student]("students")
zset.Add(Student{Name: "张三", Age: 18}, 95.5)
zset.Add(Student{Name: "李四", Age: 20}, 88.0)

// 按分数范围获取
students, _ := zset.RangeByScore(90, 100)
for _, s := range students {
    fmt.Println(s.Name, s.Age)
}

// 使用迭代器
for item := range zset.IteratorFilterByScore(0, 100) {
    fmt.Println(item.Value.Name, item.Score)
}
6. 使用 Queue
// 使用全局函数
queue := redisTool.NewQueue[Student]("tasks", redisTool.QueueConfig{
    MaxLength: 100,
    MaxWaitTime: time.Second * 5,
    MaxRetry: 3,
    ErrorHandler: func(value interface{}, err error, storage func(value interface{})) time.Duration {
        fmt.Println("Error:", err)
        return time.Second * 5 // 5 秒后重试
    },
})

// 添加任务
queue.Add(Student{Name: "张三", Age: 18})

// 添加延迟任务
queue.AddDelayed(Student{Name: "李四", Age: 20}, time.Second * 10)

// 处理任务
if value, ok := queue.Take(); ok {
    fmt.Println(value.Name)
    queue.Complete(value)
}

// 启动工作线程
queue.StartWorkers(5, func(value Student) error {
    fmt.Println("Processing:", value.Name)
    return nil
})
7. 使用 Cache
// 使用全局函数
cache := redisTool.NewCache[Student]("students", redisTool.CacheConfig{
    DefaultExpire: time.Minute * 10,
})

// 设置缓存
cache.Set("student1", Student{Name: "张三", Age: 18}, time.Minute*5)

// 获取缓存
if student, ok := cache.Get("student1"); ok {
    fmt.Println(student.Name)
}

// 获取或设置
student := cache.GetOrSet("student2", func(key string) (Student, time.Duration) {
    return Student{Name: "李四", Age: 20}, time.Minute * 5
})

// 注意：缓存会在 Set 操作时自动清理过期数据
// 使用概率性机制，在横跨分钟时触发清理，无需手动调用
8. 使用分布式锁
// 使用全局函数（推荐）
lock := redisTool.NewLock("mylock", redisTool.LockConfig{
    WaitTime: time.Second * 5,
    RetryTime: time.Second,
    MaxGetLockWaitTime: time.Second * 30,
})

if err := lock.Lock(); err != nil {
    fmt.Println("获取锁失败:", err)
    return
}
defer lock.Unlock()

// 执行业务逻辑
fmt.Println("执行业务逻辑")

// 使用闭包简化
redisTool.NewLock("mylock").LockFunc(func() {
    fmt.Println("执行业务逻辑")
})

// 尝试获取锁
if redisTool.NewLock("mylock").TryLockFunc(func() {
    fmt.Println("获得锁，执行业务逻辑")
}) {
    fmt.Println("成功")
} else {
    fmt.Println("未获得锁")
}
9. 使用辅助工具
// 使用全局函数（推荐）
// 获取上次使用时间
lastTime := redisTool.LastUseTime("mykey", true)
fmt.Println("上次使用时间:", lastTime)

// 检查是否跨越分钟
if redisTool.AcrossMinute("task1") {
    fmt.Println("跨越了分钟，执行任务")
}

// 检查是否跨越秒
if redisTool.AcrossSecond("task2") {
    fmt.Println("跨越了秒，执行任务")
}

// 检查是否跨越指定时间
if redisTool.AcrossTime("task3", time.Hour) {
    fmt.Println("跨越了小时，执行任务")
}

// 设置上次使用时间
redisTool.SetLastUseTime("mykey", time.Now())

// 获取安全类型映射
safeMap := redisTool.GetSafeTypeMap()
safeMap.Set("key1", time.Now().UnixMilli())

序列化

默认序列化器会自动处理：

  • 实现了 Serializer 接口的类型
  • 基本类型（string, int, float, bool 等）
  • 其他类型使用 gob 编码

自定义序列化：

type Student struct {
    Name string
    Age  int
}

func (s Student) Serialize() ([]byte, error) {
    return json.Marshal(s)
}

func (s *Student) Deserialize(data []byte) error {
    return json.Unmarshal(data, s)
}

配置选项

Config
  • Prefix - Redis 键前缀
  • NameCreator - 自定义键名生成函数
  • MaxIdle - 最大空闲连接数
  • MaxActive - 最大连接数
  • IdleTimeout - 空闲连接超时时间
  • MaxLifeTime - 连接最大生存时间
  • Serializer - 序列化器
  • SafeTypeMapName - 安全类型映射名称
QueueConfig
  • MaxLength - 队列最大长度
  • MaxWaitTime - 阻塞等待时间
  • MaxRetry - 最大重试次数
  • ErrorHandler - 错误处理函数
CacheConfig
  • DefaultExpire - 默认过期时间
LockConfig
  • WaitTime - 锁的持有时间
  • RetryTime - 重试间隔
  • MaxGetLockWaitTime - 获取锁的最长等待时间

注意事项

  1. 使用前需要初始化 Redis 连接
  2. 建议使用 SetDefaultConnection 设置全局连接
  3. 大量数据操作建议使用 Iterator 避免阻塞
  4. 分布式锁使用后记得释放，建议使用 defer
  5. 缓存会自动清理过期数据，也可以手动调用 ClearExpired

许可证

MIT License

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func AcrossMinute 

func AcrossMinute(key string) bool

AcrossMinute 是否跨越了分钟（全局函数）

func AcrossSecond 

func AcrossSecond(key string) bool

AcrossSecond 是否跨越了秒（全局函数）

func AcrossTime 

func AcrossTime(key string, duration time.Duration) bool

AcrossTime 是否跨越了指定的时间间隔（全局函数）

func DefaultNameCreator 

func DefaultNameCreator(config Config, types RedisType, name ...string) string

DefaultNameCreator 默认名称创建器

func LastUseTime 

func LastUseTime(key string, update bool) time.Time

LastUseTime 获取上次使用时间（全局函数）

func SetDefaultConnection 

func SetDefaultConnection(r *Redis)

SetDefaultConnection 设置默认连接

func SetLastUseTime 

func SetLastUseTime(key string, t time.Time)

SetLastUseTime 设置上次使用时间（全局函数）

Types

type Cache 

type Cache[T any] struct {
	// contains filtered or unexported fields
}

Cache 缓存

func NewCache 

func NewCache[T any](name string, config CacheConfig, r ...*Redis) *Cache[T]

NewCache 创建缓存（全局函数）

func (*Cache[T]) Clear 

func (c *Cache[T]) Clear() error

Clear 清空缓存

func (*Cache[T]) ClearExpired 

func (c *Cache[T]) ClearExpired() error

ClearExpired 清理过期的缓存

func (*Cache[T]) Delete 

func (c *Cache[T]) Delete(keys ...string) error

Delete 删除缓存

func (*Cache[T]) Exists 

func (c *Cache[T]) Exists(key string) bool

Exists 判断缓存是否存在

func (*Cache[T]) Get 

func (c *Cache[T]) Get(key string) (T, bool)

Get 获取缓存

func (*Cache[T]) GetOrSet 

func (c *Cache[T]) GetOrSet(key string, factory func(key string) (T, time.Duration)) T

GetOrSet 获取或设置缓存

func (*Cache[T]) GetTTL 

func (c *Cache[T]) GetTTL(key string) (time.Duration, bool)

GetTTL 获取剩余生存时间

func (*Cache[T]) Keys 

func (c *Cache[T]) Keys() ([]string, error)

Keys 获取所有键

func (*Cache[T]) Length 

func (c *Cache[T]) Length() int

Length 获取缓存数量

func (*Cache[T]) Set 

func (c *Cache[T]) Set(key string, value T, expire time.Duration) error

Set 设置缓存

func (*Cache[T]) SetTTL 

func (c *Cache[T]) SetTTL(key string, expire time.Duration) error

SetTTL 设置生存时间

type CacheConfig 

type CacheConfig struct {
	DefaultExpire time.Duration // 默认过期时间，0 表示不过期
}

CacheConfig 缓存配置

type Config 

type Config struct {
	Prefix          string                                                      // 项目前缀
	NameCreator     func(config Config, types RedisType, name ...string) string // 名称创建器
	MaxIdle         int                                                         // 最大空闲连接数
	MaxActive       int                                                         // 最大连接数
	IdleTimeout     time.Duration                                               // 空闲连接超时时间
	MaxLifeTime     time.Duration                                               // 活跃连接超时时间
	Serializer      SerializerFunc                                              // 序列化器
	SafeTypeMapName string                                                      // 安全类型映射名称
}

Config Redis 配置

func DefaultConfig 

func DefaultConfig() Config

DefaultConfig 默认配置

type Lock 

type Lock struct {
	// contains filtered or unexported fields
}

Lock 分布式锁

func NewLock 

func NewLock(name string, config ...LockConfig) *Lock

NewLock 创建分布式锁（全局函数）

func (*Lock) IsLocked 

func (l *Lock) IsLocked() bool

IsLocked 检查是否已锁定

func (*Lock) Lock 

func (l *Lock) Lock() error

Lock 获取锁

func (*Lock) LockFunc 

func (l *Lock) LockFunc(fn func()) error

LockFunc 使用闭包简化锁的使用

func (*Lock) Refresh 

func (l *Lock) Refresh() error

Refresh 刷新锁的过期时间

func (*Lock) StartRefreshLoop 

func (l *Lock) StartRefreshLoop() chan struct{}

StartRefreshLoop 启动自动刷新锁的循环

func (*Lock) TryLock 

func (l *Lock) TryLock() bool

TryLock 尝试获取锁

func (*Lock) TryLockFunc 

func (l *Lock) TryLockFunc(fn func()) bool

TryLockFunc 尝试使用闭包简化锁的使用

func (*Lock) Unlock 

func (l *Lock) Unlock() error

Unlock 释放锁

type LockConfig 

type LockConfig struct {
	WaitTime           time.Duration // 最长的锁时间，获得锁后，如果在这个时间内没有释放锁，视为出错，自动释放锁
	RetryTime          time.Duration // 尝试获取锁的间隔时间
	MaxGetLockWaitTime time.Duration // 获取锁最长等待时间
}

LockConfig 锁配置

type Queue 

type Queue[T any] struct {
	// contains filtered or unexported fields
}

Queue 队列

func NewQueue 

func NewQueue[T any](name string, config QueueConfig, r ...*Redis) *Queue[T]

NewQueue 创建队列（全局函数）

func (*Queue[T]) Add 

func (q *Queue[T]) Add(value T) error

Add 添加任务到队列

func (*Queue[T]) AddDelayed 

func (q *Queue[T]) AddDelayed(value T, delay time.Duration) error

AddDelayed 添加延迟任务

func (*Queue[T]) Clear 

func (q *Queue[T]) Clear() error

Clear 清空队列

func (*Queue[T]) Complete 

func (q *Queue[T]) Complete(value T) error

Complete 完成任务

func (*Queue[T]) DelayedLength 

func (q *Queue[T]) DelayedLength() int

DelayedLength 获取延迟队列长度

func (*Queue[T]) Fail 

func (q *Queue[T]) Fail(value T, err error) error

Fail 任务失败

func (*Queue[T]) Length 

func (q *Queue[T]) Length() int

Length 获取队列长度

func (*Queue[T]) ProcessingLength 

func (q *Queue[T]) ProcessingLength() int

ProcessingLength 获取处理中队列长度

func (*Queue[T]) StartWorker 

func (q *Queue[T]) StartWorker(handler func(value T) error)

StartWorker 启动工作线程

func (*Queue[T]) StartWorkers 

func (q *Queue[T]) StartWorkers(count int, handler func(value T) error)

StartWorkers 启动多个工作线程

func (*Queue[T]) Take 

func (q *Queue[T]) Take() (T, bool)

Take 获取任务

type QueueConfig 

type QueueConfig struct {
	MaxLength    int                                                                               // 队列最大长度，0 表示不限制
	MaxWaitTime  time.Duration                                                                     // 队列阻塞等待时间，0 表示不阻塞
	MaxRetry     int                                                                               // 队列重试次数，0 表示不重试
	ErrorHandler func(value interface{}, err error, storage func(value interface{})) time.Duration // 错误处理器
}

QueueConfig 队列配置

type Redis 

type Redis struct {
	// contains filtered or unexported fields
}

Redis Redis 客户端

func GetDefaultConnection 

func GetDefaultConnection() *Redis

GetDefaultConnection 获取默认连接

func (*Redis) AcrossMinute 

func (r *Redis) AcrossMinute(key string) bool

AcrossMinute 是否跨越了分钟

func (*Redis) AcrossSecond 

func (r *Redis) AcrossSecond(key string) bool

AcrossSecond 是否跨越了秒

func (*Redis) AcrossTime 

func (r *Redis) AcrossTime(key string, duration time.Duration) bool

AcrossTime 是否跨越了指定的时间间隔

func (*Redis) CleanSafeTypeMap 

func (r *Redis) CleanSafeTypeMap(expireDuration time.Duration) error

CleanSafeTypeMap 清理安全类型映射中的过期数据

func (*Redis) Close 

func (r *Redis) Close() error

Close 关闭连接池

func (*Redis) CreateName 

func (r *Redis) CreateName(redisType RedisType, name ...string) string

CreateName 创建 Redis 键名

func (*Redis) DeleteLastUseTime 

func (r *Redis) DeleteLastUseTime(keys ...string) error

DeleteLastUseTime 删除上次使用时间

func (*Redis) Deserialize 

func (r *Redis) Deserialize(data []byte, v interface{}) error

Deserialize 反序列化

func (*Redis) Do 

func (r *Redis) Do(commandName string, args ...interface{}) (interface{}, error)

Do 执行 Redis 命令

func (*Redis) DoWithConn 

func (r *Redis) DoWithConn(conn redis.Conn, commandName string, args ...interface{}) (interface{}, error)

DoWithConn 使用指定连接执行 Redis 命令

func (*Redis) GetConn 

func (r *Redis) GetConn() redis.Conn

GetConn 获取连接

func (*Redis) GetConnWithContext 

func (r *Redis) GetConnWithContext(ctx context.Context) (redis.Conn, error)

GetConnWithContext 获取带上下文的连接

func (*Redis) GetSafeTypeMap 

func (r *Redis) GetSafeTypeMap() *RedisTypeMap[int64]

GetSafeTypeMap 获取安全类型映射

func (*Redis) LastUseTime 

func (r *Redis) LastUseTime(key string, update bool) time.Time

LastUseTime 获取上次使用时间

func (*Redis) NewList 

func (r *Redis) NewList(name string) *RedisList

NewList 创建列表

func (*Redis) NewLock 

func (r *Redis) NewLock(name string, config ...LockConfig) *Lock

NewLock 创建分布式锁

func (*Redis) NewMap 

func (r *Redis) NewMap(name string) *RedisMap

NewMap 创建哈希表

func (*Redis) NewNumberMap 

func (r *Redis) NewNumberMap(name string) *RedisNumberMap

NewNumberMap 创建数字型哈希表

func (*Redis) NewSet 

func (r *Redis) NewSet(name string) *RedisSet

NewSet 创建集合

func (*Redis) NewZSet 

func (r *Redis) NewZSet(name string) *RedisZSet

NewZSet 创建有序集合

func (*Redis) Serialize 

func (r *Redis) Serialize(v interface{}) ([]byte, error)

Serialize 序列化

func (*Redis) SetLastUseTime 

func (r *Redis) SetLastUseTime(key string, t time.Time) error

SetLastUseTime 设置上次使用时间

type RedisBuilder 

type RedisBuilder struct {
	// contains filtered or unexported fields
}

Builder 构建器

func Builder 

func Builder(addr, password string) *RedisBuilder

Builder 创建 Redis 构建器

func (*RedisBuilder) Build 

func (b *RedisBuilder) Build() *Redis

Build 构建 Redis 客户端

func (*RedisBuilder) Config 

func (b *RedisBuilder) Config(config Config) *RedisBuilder

Config 设置配置

type RedisList 

type RedisList struct {
	// contains filtered or unexported fields
}

RedisList Redis 列表

func (*RedisList) Clear 

func (l *RedisList) Clear() error

Clear 清空列表

func (*RedisList) DeleteIndex 

func (l *RedisList) DeleteIndex(index int) error

DeleteIndex 删除指定索引的元素（通过设置标记并移除）

func (*RedisList) DeleteRange 

func (l *RedisList) DeleteRange(start, end int) error

DeleteRange 删除指定范围外的元素

func (*RedisList) DeleteValue 

func (l *RedisList) DeleteValue(value interface{}, count int) error

DeleteValue 删除指定值的元素

func (*RedisList) Exists 

func (l *RedisList) Exists() bool

Exists 判断列表是否存在

func (*RedisList) Get 

func (l *RedisList) Get(start, end int) ([]interface{}, error)

Get 获取指定范围的元素

func (*RedisList) Index 

func (l *RedisList) Index(index int) (interface{}, bool)

Index 获取指定索引的元素

func (*RedisList) IsEmpty 

func (l *RedisList) IsEmpty() bool

IsEmpty 判断列表是否为空

func (*RedisList) IsNotEmpty 

func (l *RedisList) IsNotEmpty() bool

IsNotEmpty 判断列表是否不为空

func (*RedisList) Iterator 

func (l *RedisList) Iterator(batchSize int) <-chan interface{}

Iterator 获取迭代器

func (*RedisList) Length 

func (l *RedisList) Length() int

Length 获取列表长度

func (*RedisList) Pop 

func (l *RedisList) Pop() (interface{}, bool)

Pop 从右侧弹出元素

func (*RedisList) Push 

func (l *RedisList) Push(value interface{}) error

Push 从右侧推入元素

func (*RedisList) SafeUpset 

func (l *RedisList) SafeUpset(index int, value interface{}) (interface{}, bool, error)

SafeUpset 安全更新（多实例安全）

func (*RedisList) Set 

func (l *RedisList) Set(index int, value interface{}) error

Set 设置指定索引的元素

func (*RedisList) Shift 

func (l *RedisList) Shift() (interface{}, bool)

Shift 从左侧弹出元素

func (*RedisList) Unshift 

func (l *RedisList) Unshift(value interface{}) error

Unshift 从左侧推入元素

type RedisMap 

type RedisMap struct {
	// contains filtered or unexported fields
}

RedisMap Redis 哈希表

func (*RedisMap) Clear 

func (m *RedisMap) Clear() error

Clear 清空哈希表

func (*RedisMap) Delete 

func (m *RedisMap) Delete(keys ...string) error

Delete 删除键

func (*RedisMap) Exists 

func (m *RedisMap) Exists(key string) bool

Exists 判断键是否存在

func (*RedisMap) Get 

func (m *RedisMap) Get(key string) (interface{}, bool)

Get 获取值

func (*RedisMap) IsEmpty 

func (m *RedisMap) IsEmpty() bool

IsEmpty 判断哈希表是否为空

func (*RedisMap) IsNotEmpty 

func (m *RedisMap) IsNotEmpty() bool

IsNotEmpty 判断哈希表是否不为空

func (*RedisMap) Iterator 

func (m *RedisMap) Iterator(batchSize int) <-chan struct {
	Key   string
	Value interface{}
}

Iterator 获取迭代器

func (*RedisMap) Keys 

func (m *RedisMap) Keys() ([]string, error)

Keys 获取所有键

func (*RedisMap) Length 

func (m *RedisMap) Length() int

Length 获取哈希表大小

func (*RedisMap) Set 

func (m *RedisMap) Set(key string, value interface{}) error

Set 设置键值

func (*RedisMap) ToArray 

func (m *RedisMap) ToArray() (map[string]interface{}, error)

ToArray 获取所有键值对

type RedisNumberMap 

type RedisNumberMap struct {
	// contains filtered or unexported fields
}

RedisNumberMap 数字型 Redis 哈希表

func (*RedisNumberMap) Clear 

func (nm *RedisNumberMap) Clear() error

Clear 清空哈希表

func (*RedisNumberMap) Decrement 

func (nm *RedisNumberMap) Decrement(key string, delta float64) (float64, error)

Decrement 减少数值

func (*RedisNumberMap) Delete 

func (nm *RedisNumberMap) Delete(keys ...string) error

Delete 删除键

func (*RedisNumberMap) Exists 

func (nm *RedisNumberMap) Exists(key string) bool

Exists 判断键是否存在

func (*RedisNumberMap) Get 

func (nm *RedisNumberMap) Get(key string) (float64, bool)

Get 获取数值

func (*RedisNumberMap) Increment 

func (nm *RedisNumberMap) Increment(key string, delta float64) (float64, error)

Increment 增加数值

func (*RedisNumberMap) IsEmpty 

func (nm *RedisNumberMap) IsEmpty() bool

IsEmpty 判断哈希表是否为空

func (*RedisNumberMap) IsNotEmpty 

func (nm *RedisNumberMap) IsNotEmpty() bool

IsNotEmpty 判断哈希表是否不为空

func (*RedisNumberMap) Keys 

func (nm *RedisNumberMap) Keys() ([]string, error)

Keys 获取所有键

func (*RedisNumberMap) Length 

func (nm *RedisNumberMap) Length() int

Length 获取哈希表大小

func (*RedisNumberMap) Set 

func (nm *RedisNumberMap) Set(key string, value float64) error

Set 设置数值

func (*RedisNumberMap) ToArray 

func (nm *RedisNumberMap) ToArray() (map[string]float64, error)

ToArray 获取所有键值对

type RedisSet 

type RedisSet struct {
	// contains filtered or unexported fields
}

RedisSet Redis 集合

func (*RedisSet) Add 

func (s *RedisSet) Add(values ...interface{}) error

Add 添加元素

func (*RedisSet) Clear 

func (s *RedisSet) Clear() error

Clear 清空集合

func (*RedisSet) Exists 

func (s *RedisSet) Exists(value interface{}) bool

Exists 判断元素是否存在

func (*RedisSet) IsEmpty 

func (s *RedisSet) IsEmpty() bool

IsEmpty 判断集合是否为空

func (*RedisSet) IsNotEmpty 

func (s *RedisSet) IsNotEmpty() bool

IsNotEmpty 判断集合是否不为空

func (*RedisSet) Iterator 

func (s *RedisSet) Iterator(batchSize int) <-chan interface{}

Iterator 获取迭代器

func (*RedisSet) Length 

func (s *RedisSet) Length() int

Length 获取集合大小

func (*RedisSet) Remove 

func (s *RedisSet) Remove(values ...interface{}) error

Remove 移除元素

func (*RedisSet) ToArray 

func (s *RedisSet) ToArray() ([]interface{}, error)

ToArray 获取所有元素

type RedisType 

type RedisType int

RedisType Redis 数据类型枚举 

const (
	RedisTypeString RedisType = iota
	RedisTypeList_
	RedisTypeSet_
	RedisTypeZSet_
	RedisTypeHash_
	RedisTypeQueue_
	RedisTypeCache_
	RedisTypeLock_
	RedisTypeSafeTypeMap_
)

func (RedisType) String 

func (rt RedisType) String() string

String 返回 RedisType 的字符串表示

type RedisTypeList 

type RedisTypeList[T any] struct {
	// contains filtered or unexported fields
}

RedisTypeList 类型化的 Redis 列表

func NewTypeList 

func NewTypeList[T any](name string, r ...*Redis) *RedisTypeList[T]

NewTypeList 创建类型化列表（全局函数）

func (*RedisTypeList[T]) Clear 

func (tl *RedisTypeList[T]) Clear() error

Clear 清空列表

func (*RedisTypeList[T]) DeleteIndex 

func (tl *RedisTypeList[T]) DeleteIndex(index int) error

DeleteIndex 删除指定索引的元素

func (*RedisTypeList[T]) DeleteRange 

func (tl *RedisTypeList[T]) DeleteRange(start, end int) error

DeleteRange 删除指定范围外的元素

func (*RedisTypeList[T]) DeleteValue 

func (tl *RedisTypeList[T]) DeleteValue(value T, count int) error

DeleteValue 删除指定值的元素

func (*RedisTypeList[T]) Exists 

func (tl *RedisTypeList[T]) Exists() bool

Exists 判断列表是否存在

func (*RedisTypeList[T]) Get 

func (tl *RedisTypeList[T]) Get(start, end int) ([]T, error)

Get 获取指定范围的元素

func (*RedisTypeList[T]) Index 

func (tl *RedisTypeList[T]) Index(index int) (T, bool)

Index 获取指定索引的元素

func (*RedisTypeList[T]) IsEmpty 

func (tl *RedisTypeList[T]) IsEmpty() bool

IsEmpty 判断列表是否为空

func (*RedisTypeList[T]) IsNotEmpty 

func (tl *RedisTypeList[T]) IsNotEmpty() bool

IsNotEmpty 判断列表是否不为空

func (*RedisTypeList[T]) Iterator 

func (tl *RedisTypeList[T]) Iterator(batchSize int) <-chan T

Iterator 获取迭代器

func (*RedisTypeList[T]) Length 

func (tl *RedisTypeList[T]) Length() int

Length 获取列表长度

func (*RedisTypeList[T]) Pop 

func (tl *RedisTypeList[T]) Pop() (T, bool)

Pop 弹出元素

func (*RedisTypeList[T]) Push 

func (tl *RedisTypeList[T]) Push(value T) error

Push 推入元素

func (*RedisTypeList[T]) SafeUpset 

func (tl *RedisTypeList[T]) SafeUpset(index int, value T) (T, bool, error)

SafeUpset 安全更新

func (*RedisTypeList[T]) Set 

func (tl *RedisTypeList[T]) Set(index int, value T) error

Set 设置指定索引的元素

func (*RedisTypeList[T]) Shift 

func (tl *RedisTypeList[T]) Shift() (T, bool)

Shift 从左侧弹出元素

func (*RedisTypeList[T]) Unshift 

func (tl *RedisTypeList[T]) Unshift(value T) error

Unshift 从左侧推入元素

type RedisTypeMap 

type RedisTypeMap[T any] struct {
	// contains filtered or unexported fields
}

RedisTypeMap 类型化的 Redis 哈希表

func GetSafeTypeMap 

func GetSafeTypeMap() *RedisTypeMap[int64]

GetSafeTypeMap 获取安全类型映射（全局函数）

func NewTypeMap 

func NewTypeMap[T any](name string, r ...*Redis) *RedisTypeMap[T]

NewTypeMap 创建类型化哈希表（全局函数）

func (*RedisTypeMap[T]) Clear 

func (tm *RedisTypeMap[T]) Clear() error

Clear 清空哈希表

func (*RedisTypeMap[T]) Delete 

func (tm *RedisTypeMap[T]) Delete(keys ...string) error

Delete 删除键

func (*RedisTypeMap[T]) Exists 

func (tm *RedisTypeMap[T]) Exists(key string) bool

Exists 判断键是否存在

func (*RedisTypeMap[T]) Get 

func (tm *RedisTypeMap[T]) Get(key string) (T, bool)

Get 获取值

func (*RedisTypeMap[T]) IsEmpty 

func (tm *RedisTypeMap[T]) IsEmpty() bool

IsEmpty 判断哈希表是否为空

func (*RedisTypeMap[T]) IsNotEmpty 

func (tm *RedisTypeMap[T]) IsNotEmpty() bool

IsNotEmpty 判断哈希表是否不为空

func (*RedisTypeMap[T]) Iterator 

func (tm *RedisTypeMap[T]) Iterator(batchSize int) <-chan struct {
	Key   string
	Value T
}

Iterator 获取迭代器

func (*RedisTypeMap[T]) Keys 

func (tm *RedisTypeMap[T]) Keys() ([]string, error)

Keys 获取所有键

func (*RedisTypeMap[T]) Length 

func (tm *RedisTypeMap[T]) Length() int

Length 获取哈希表大小

func (*RedisTypeMap[T]) SafeUpset 

func (tm *RedisTypeMap[T]) SafeUpset(key string, value T) (T, bool, error)

SafeUpset 安全更新（多实例安全）

func (*RedisTypeMap[T]) Set 

func (tm *RedisTypeMap[T]) Set(key string, value T) error

Set 设置键值

func (*RedisTypeMap[T]) ToArray 

func (tm *RedisTypeMap[T]) ToArray() (map[string]T, error)

ToArray 获取所有键值对

type RedisTypeSet 

type RedisTypeSet[T any] struct {
	// contains filtered or unexported fields
}

RedisTypeSet 类型化的 Redis 集合

func NewTypeSet 

func NewTypeSet[T any](name string, r ...*Redis) *RedisTypeSet[T]

NewTypeSet 创建类型化集合（全局函数）

func (*RedisTypeSet[T]) Add 

func (ts *RedisTypeSet[T]) Add(values ...T) error

Add 添加元素

func (*RedisTypeSet[T]) Clear 

func (ts *RedisTypeSet[T]) Clear() error

Clear 清空集合

func (*RedisTypeSet[T]) Exists 

func (ts *RedisTypeSet[T]) Exists(value T) bool

Exists 判断元素是否存在

func (*RedisTypeSet[T]) IsEmpty 

func (ts *RedisTypeSet[T]) IsEmpty() bool

IsEmpty 判断集合是否为空

func (*RedisTypeSet[T]) IsNotEmpty 

func (ts *RedisTypeSet[T]) IsNotEmpty() bool

IsNotEmpty 判断集合是否不为空

func (*RedisTypeSet[T]) Iterator 

func (ts *RedisTypeSet[T]) Iterator(batchSize int) <-chan T

Iterator 获取迭代器

func (*RedisTypeSet[T]) Length 

func (ts *RedisTypeSet[T]) Length() int

Length 获取集合大小

func (*RedisTypeSet[T]) Remove 

func (ts *RedisTypeSet[T]) Remove(values ...T) error

Remove 移除元素

func (*RedisTypeSet[T]) ToArray 

func (ts *RedisTypeSet[T]) ToArray() ([]T, error)

ToArray 获取所有元素

type RedisTypeZSet 

type RedisTypeZSet[T any] struct {
	// contains filtered or unexported fields
}

RedisTypeZSet 类型化的 Redis 有序集合

func NewTypeZSet 

func NewTypeZSet[T any](name string, r ...*Redis) *RedisTypeZSet[T]

NewTypeZSet 创建类型化有序集合（全局函数）

func (*RedisTypeZSet[T]) Add 

func (tz *RedisTypeZSet[T]) Add(value T, score float64) error

Add 添加元素

func (*RedisTypeZSet[T]) Clear 

func (tz *RedisTypeZSet[T]) Clear() error

Clear 清空有序集合

func (*RedisTypeZSet[T]) IncrementScore 

func (tz *RedisTypeZSet[T]) IncrementScore(value T, delta float64) (float64, error)

IncrementScore 增加元素的分数

func (*RedisTypeZSet[T]) IsEmpty 

func (tz *RedisTypeZSet[T]) IsEmpty() bool

IsEmpty 判断有序集合是否为空

func (*RedisTypeZSet[T]) IsNotEmpty 

func (tz *RedisTypeZSet[T]) IsNotEmpty() bool

IsNotEmpty 判断有序集合是否不为空

func (*RedisTypeZSet[T]) Iterator 

func (tz *RedisTypeZSet[T]) Iterator(batchSize int) <-chan ZSetItem[T]

Iterator 获取迭代器

func (*RedisTypeZSet[T]) IteratorFilterByScore 

func (tz *RedisTypeZSet[T]) IteratorFilterByScore(min, max float64) <-chan ZSetItem[T]

IteratorFilterByScore 按分数过滤的迭代器

func (*RedisTypeZSet[T]) Length 

func (tz *RedisTypeZSet[T]) Length() int

Length 获取有序集合大小

func (*RedisTypeZSet[T]) RangeByRank 

func (tz *RedisTypeZSet[T]) RangeByRank(start, stop int) ([]T, error)

RangeByRank 按排名范围获取元素

func (*RedisTypeZSet[T]) RangeByScore 

func (tz *RedisTypeZSet[T]) RangeByScore(min, max float64) ([]T, error)

RangeByScore 按分数范围获取元素

func (*RedisTypeZSet[T]) Remove 

func (tz *RedisTypeZSet[T]) Remove(values ...T) error

Remove 移除元素

func (*RedisTypeZSet[T]) RemoveRangeByScore 

func (tz *RedisTypeZSet[T]) RemoveRangeByScore(min, max float64) error

RemoveRangeByScore 按分数范围删除元素

func (*RedisTypeZSet[T]) Score 

func (tz *RedisTypeZSet[T]) Score(value T) (v float64, exist bool)

Score 获取元素的分数

type RedisZSet 

type RedisZSet struct {
	// contains filtered or unexported fields
}

RedisZSet Redis 有序集合

func (*RedisZSet) Add 

func (z *RedisZSet) Add(value interface{}, score float64) error

Add 添加元素

func (*RedisZSet) Clear 

func (z *RedisZSet) Clear() error

Clear 清空有序集合

func (*RedisZSet) IncrementScore 

func (z *RedisZSet) IncrementScore(value interface{}, delta float64) (float64, error)

IncrementScore 增加元素的分数

func (*RedisZSet) IsEmpty 

func (z *RedisZSet) IsEmpty() bool

IsEmpty 判断有序集合是否为空

func (*RedisZSet) IsNotEmpty 

func (z *RedisZSet) IsNotEmpty() bool

IsNotEmpty 判断有序集合是否不为空

func (*RedisZSet) Iterator 

func (z *RedisZSet) Iterator(batchSize int) <-chan struct {
	Value interface{}
	Score float64
}

Iterator 获取迭代器（按分数过滤）

func (*RedisZSet) Length 

func (z *RedisZSet) Length() int

Length 获取有序集合大小

func (*RedisZSet) RangeByRank 

func (z *RedisZSet) RangeByRank(start, stop int) ([]interface{}, error)

RangeByRank 按排名范围获取元素

func (*RedisZSet) RangeByScore 

func (z *RedisZSet) RangeByScore(min, max float64, withScores bool) ([]interface{}, error)

RangeByScore 按分数范围获取元素

func (*RedisZSet) Remove 

func (z *RedisZSet) Remove(values ...interface{}) error

Remove 移除元素

func (*RedisZSet) RemoveRangeByScore 

func (z *RedisZSet) RemoveRangeByScore(min, max float64) error

RemoveRangeByScore 按分数范围删除元素

func (*RedisZSet) Score 

func (z *RedisZSet) Score(value interface{}) (float64, bool)

Score 获取元素的分数

type Serializer 

type Serializer interface {
	Serialize() ([]byte, error)
	Deserialize(data []byte) error
}

Serializer 序列化接口

type SerializerFunc 

type SerializerFunc interface {
	Serialize(v interface{}) ([]byte, error)
	Deserialize(data []byte, v interface{}) error
}

SerializerFunc 序列化函数接口 

var DefaultSerializer SerializerFunc = &defaultSerializer{}

DefaultSerializer 默认序列化器实例

type TestRedis 

type TestRedis struct {
	Redis     *Redis
	MiniRedis *miniredis.Miniredis
	// contains filtered or unexported fields
}

TestRedis 测试用的 Redis 实例

func NewTestRedis 

func NewTestRedis(t *testing.T) *TestRedis

NewTestRedis 创建测试用的 Redis 实例 通过环境变量 USE_REAL_REDIS=1 可以使用真实 Redis (localhost:16379) 通过环境变量 REDIS_ADDR 可以自定义 Redis 地址

func (*TestRedis) Close 

func (tr *TestRedis) Close()

Close 关闭测试 Redis

func (*TestRedis) FastForward 

func (tr *TestRedis) FastForward(seconds int)

FastForward 快进时间（仅在 miniredis 模式下有效）

func (*TestRedis) FlushAll 

func (tr *TestRedis) FlushAll()

FlushAll 清空所有数据

type ZSetItem 

type ZSetItem[T any] struct {
	Value T
	Score float64
}

ZSetItem ZSet 项

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.