cache

package
v1.0.4 Latest Latest
Warning

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

Go to latest
Published: Oct 9, 2026 License: MIT Imports: 10 Imported by: 0

README

cache 缓存访问包

基于 go-redis v9 的 Redis 接入封装:连接管理、基础命令封装、分布式锁与延迟队列一体化。所有封装方法均不接收 context 参数,单次命令的上下文超时时间在连接配置 Redis.ContextTimeout 中统一设定,由封装内部为每次命令创建带超时的 context,完成统一的上下文管理。

特性

  • 上下文统一管理:封装方法零 context 参数,命令超时统一由 ContextTimeout 配置,封装内部按次创建并释放 context,业务方无需在每次调用时传递超时参数
  • 全局连接管理:Connect() 成功后注入全局,任意位置直接调用包级方法(Set / Get / Lock 等)
  • 全量基础命令:覆盖 key / string / hash / list / set / zset 常用操作,未封装的高级命令经 Client() 使用原生客户端执行
  • 安全分布式锁:SET NX + 持有者随机值抢占,释放与续期经 Lua 脚本原子执行,杜绝误删/误续他人的锁;支持自旋等待与续期
  • 延迟队列:sorted set 实现延迟消费(到期毫秒时间戳作 score),原子 ZREM 抢占、多实例部署天然分摊,失败自动重试、超过最大尝试次数丢弃并记日志,Stop 等待在途回调完成
  • 配置即全:连接、连接池、命令超时、锁等待一次配置全部生效,字段带 yaml / toml / json / mapstructure 标签
  • 开箱默认值:超时与锁配置未设置(<=0)时由 Connect() 自动填充默认值(建连 5s / 读写 3s / 命令上下文 3s / 锁等待 5s / 重试间隔 100ms),零配置即可安全使用
  • 集群兼容:SetClient 接收 redis.UniversalClient,cluster / sentinel 客户端可手动注入

目录结构

cache/
├── redis.go        核心包: Redis/RedisPool 配置、连接管理、全局客户端与上下文管理
├── operation.go    基础命令封装(key/string/hash/list/set/zset)
├── lock.go         分布式锁(TryLock/Lock/Unlock/Extend)
├── boot.go         组件适配器: NewBoot 一行接入 app 的 Wire 装配钩子
└── delay_queue.go  延迟队列(Push/Start/Stop, 到期消费 + 失败重试)

快速开始

package main

import (
	"time"

	"gitee.com/usmos/basic-go/cache"
)

func main() {
	r := &cache.Redis{
		Host:     "127.0.0.1",
		Port:     6379,
		Password: "123456",
		DB:       0,
		// 超时/连接池/锁配置可不设, 未设置时由 Connect 自动填充默认值
	}

	// 连接(含 Ping 探活), 成功后注入全局
	if err := r.Connect(); err != nil {
		panic(err)
	}
	defer cache.Close()

	// 基础命令, 任意位置直接调用, 无需传递 context
	_ = cache.Set("name", "note", time.Minute)
	name, err := cache.Get("name")
	if err != nil {
		// key 不存在时 err 为 cache.Nil
	}
	_ = cache.HSet("user:1", "name", "note")

	// 分布式锁(锁被占用时按配置自旋等待)
	lock, err := cache.Lock("lock:order:1", time.Minute)
	if err != nil {
		return // 获取失败(ErrLockNotAcquired)
	}
	defer lock.Unlock()
}

与 config 配合,从配置文件加载:

type Root struct {
	Redis cache.Redis `yaml:"redis"`
}

var c Root
cfg, _ := config.New("yaml", config.WithFile("config.yaml"))
_ = cfg.UnmarshalWithDefault(&c)
_ = c.Redis.Connect()

对应配置文件:

redis:
  host: 127.0.0.1
  port: 6379
  username: ""             # redis 6.0+ acl 用户名, 可省略
  password: "123456"
  db: 0
  dial_timeout: 5s         # 建立连接的超时时间(默认 5s, 可省略)
  read_timeout: 3s         # 读取(命令执行)的超时时间(默认 3s, 可省略)
  write_timeout: 3s        # 写入的超时时间(默认 3s, 可省略)
  context_timeout: 3s       # 单次命令的上下文超时时间(封装层核心超时, 默认 3s, 可省略)
  pool_size: 100            # 连接池最大连接数
  max_idle_conns: 30        # 连接池最大空闲连接数
  min_idle_conns: 5         # 连接池最小空闲连接数(提前建立并保活)
  conn_max_idle_time: 5m    # 连接最大空闲时间
  conn_max_lifetime: 30m    # 连接最大生命周期
  max_retries: 3            # 命令失败最大重试次数(-1 表示禁用)
  lock_wait_timeout: 5s     # Lock 自旋获取锁的最大等待时间(默认 5s, 可省略)
  lock_retry_interval: 200ms # Lock 自旋获取锁的重试间隔(默认 100ms, 可省略)

快捷接入 app

app 的 Wire 装配钩子中一行接入——建连、Ping 探活、关停释放由适配器托管:

app.MustRun(&app.Boot[Conf]{
	Wire: func(c *Conf) []app.Component {
		return []app.Component{cache.NewBoot(&c.Redis)}
	},
})

连接为全局单例:Connect 注入包级全局 Client(),Wire 中放置多个 cache.Boot 会互相覆盖。

上下文管理

所有封装方法不接收 context:连接配置中的超时参数在 Connect() 时注入全局,封装内部为每次命令创建带超时的 context 并在命令结束后释放:

Redis.ContextTimeout ──Connect()──> 全局 commandTimeout
Set/Get/Del/Lock...  ──每次调用──> cmdCtx(): context.WithTimeout(Background, commandTimeout)

context_timeout 未设置(<=0)时默认 3s,由 Connect() 自动填充(见 applyDefaults);长时间命令(如大批量 Scan)需显式调大。

配置字段

连接池(RedisPool,内嵌于 Redis,见 redis.go):

字段 类型 说明
pool_size int 连接池最大连接数(go-redis 默认 10×GOMAXPROCS)
max_idle_conns int 连接池最大空闲连接数
min_idle_conns int 连接池最小空闲连接数(提前建立并保活)
conn_max_idle_time time.Duration 连接最大空闲时间(go-redis 默认 30m)
conn_max_lifetime time.Duration 连接最大生命周期(0 = 不限制)
max_retries int 命令失败最大重试次数(go-redis 默认 3,-1 禁用)

连接与超时(Redis):

字段 类型 说明
host / port string / int redis 地址
username / password string 认证信息(username 为 redis 6.0+ acl,可省略)
db int 数据库编号
dial_timeout time.Duration 建连超时(默认 5s)
read_timeout time.Duration 读超时(默认 3s)
write_timeout time.Duration 写超时(默认 3s)
context_timeout time.Duration 单次命令的上下文超时时间,封装层核心超时(默认 3s)

分布式锁(Redis):

字段 类型 说明
lock_wait_timeout time.Duration Lock 自旋获取锁的最大等待时间(默认 5s;仅尝试一次请使用 TryLock)
lock_retry_interval time.Duration Lock 自旋获取锁的重试间隔(默认 100ms)

接口总览

核心包(redis.go):

方法 说明
Redis.Addr() 生成连接地址 host:port
Redis.Connect() 建连 → 应用连接池配置 → Ping 探活 → 注入全局
SetClient(c) 手动注入全局客户端(cluster / sentinel 场景)
Client() 获取原生 redis.UniversalClient,执行本包未封装的高级命令
Close() 关闭连接并清空全局客户端,可重复调用
NewBoot(r) app Wire 组件适配器(boot.go):Init 建连 + Ping 探活,Close 释放连接

基础命令(operation.go,均不接收 context):

分类 方法
key Del Exists Expire TTL Persist
string Set SetNX Get MSet MGet Incr IncrBy Decr DecrBy
hash HSet HMSet HGet HGetAll HDel
list LPush RPush LPop RPop LLen LRange
set SAdd SRem SMembers SIsMember SCard
zset ZAdd ZRem ZRange ZRangeWithScores ZScore ZCard

分布式锁(lock.go):

方法 / 标识符 说明
TryLock(key, expiration) 一次性抢占,锁被占用时立即返回 ErrLockNotAcquired
Lock(key, expiration) 自旋获取:按 lock_retry_interval 重试,超出 lock_wait_timeout 返回 ErrLockNotAcquired
lock.Unlock() Lua 原子释放,仅删除自己持有的锁;锁已过期/易主返回 ErrLockNotHeld
lock.Extend(expiration) Lua 原子续期,将过期时间重置为 expiration;锁已易主返回 false
Nil redis.Nil 别名,key 不存在时 Get / HGet / ZScore / LPop 等返回该错误
ErrLockNotAcquired / ErrLockNotHeld 锁哨兵错误,用 errors.Is 判断

延迟队列(delay_queue.go):

方法 / 标识符 说明
NewDelayQueue(key, handler) 创建延迟队列:key 为 sorted set 键名,handler 为消费回调(返回 nil 表示消费成功,返回 error 触发重试)
q.Push(payload, delay) 投递消息:delay 之后可消费(<=0 立即);与队列是否已 Start 无关
q.Start() 启动单消费协程(非阻塞),重复调用返回错误
q.Stop() 停止消费并等待在途回调执行完成,可重复调用

分布式锁示例

// 一次性抢占(锁被占用时立即失败)
lock, err := cache.TryLock("lock:order:1", 30*time.Second)
if err != nil {
	if errors.Is(err, cache.ErrLockNotAcquired) {
		// 锁被其他持有者占用, 放弃或稍后重试
	}
	return err
}
defer lock.Unlock()

// 长任务: 持有期间续期, 防止业务未完成锁已过期被他人抢走
ok, err := lock.Extend(30 * time.Second)
if !ok {
	// 锁已过期或易主, 需停止业务
}

// 自旋等待版本: 被占用时按 lock_wait_timeout/lock_retry_interval 配置等待
lock, err = cache.Lock("lock:order:1", 30*time.Second)

延迟队列示例

DelayQueue 基于 sorted set:到期毫秒时间戳作 score,消费协程轮询到期消息,原子 ZREM 抢占成功后执行回调——多实例部署天然分摊(谁删到谁消费);回调返回 error 或 panic 都触发重试(重新入队),超过 MaxAttempts 丢弃并记 Error 日志。消息在 redis 中为 JSON 信封(payload + attempts),业务回调只收 payload 字符串,无感知。

可调字段(DelayQueue,须在 Start 前设置,未设置(<=0)时由 Start 自动填充默认值):

字段 类型 说明
PollInterval time.Duration 消费轮询间隔(默认 1s),决定投递精度下限
BatchSize int 单轮最多取出的到期消息数(默认 10)
MaxAttempts int 最大尝试次数,含首次消费(默认 3)
RetryDelay time.Duration 消费失败后的重试等待时长(默认 1s)
// 创建: key 为 sorted set 键名, handler 返回 nil 表示消费成功
q := cache.NewDelayQueue("queue:order:timeout", func(payload string) error {
	return cancelTimeoutOrder(payload) // 返回 error 触发重试
})

q.PollInterval = 500 * time.Millisecond // 可调字段在 Start 前设置
_ = q.Push(`{"orderID":1001}`, 30*time.Minute) // 30 分钟后可消费; delay<=0 立即

if err := q.Start(); err != nil { // 启动单消费协程(非阻塞), 重复调用报错
	panic(err)
}
defer q.Stop() // 停止并等待在途回调完成, 可重复调用

接入 app 的 Init / Close 钩子:

var timeoutQueue *cache.DelayQueue // 包级变量, 供钩子间共享

app.MustRun(&app.Boot[Conf]{
	Init: func(c *Conf) error {
		timeoutQueue = cache.NewDelayQueue("queue:order:timeout", cancelTimeoutOrder)
		return timeoutQueue.Start() // 消费协程随应用启动
	},
	Close: func() { timeoutQueue.Stop() }, // HTTP 停机后停止消费, 等待在途回调
})

注意事项

  • 先连接后使用:包级方法依赖 Connect() 注入的全局客户端,未连接直接调用会触发空指针 panic(与 database 的 DB() 行为一致)
  • key 不存在判断:Get / HGet / ZScore / LPop / RPop 在 key 或成员不存在时返回 Nil,用 errors.Is(err, cache.Nil) 判断
  • 锁过期时间必须大于 0:防止持有者异常退出后锁永不释放;业务耗时不确定时用 Extend 续期,或设置足够长的过期时间
  • Unlock 语义:锁已过期或被其他持有者持有时返回 ErrLockNotHeld 而非静默成功,defer lock.Unlock() 场景可按需忽略或记录该错误
  • 延迟队列:单队列单协程顺序消费,回调内不宜执行长阻塞任务(会拖住同队列的后续消息);投递精度下限为 PollInterval
  • 高级命令:Scan / BLPop / Pipeline / Pub/Sub 等未封装命令通过 Client() 获取原生客户端执行,需自行管理 context
  • SetClient 场景:超时与锁默认值由 Connect() 填充,经 SetClient 手动注入客户端时不生效——此时命令无上下文超时(仅受 socket 超时保护),Lock 等价于 TryLock 不自旋等待
  • 集群接入:Redis.Connect() 创建单机客户端;cluster / sentinel 用户自建客户端后经 SetClient 注入,包级方法与分布式锁随之兼容(Lua 脚本按键路由)

Documentation

Overview

Package cache 提供基于 Redis 的缓存接入:连接管理、基础命令封装、分布式锁与延迟队列。

上下文管理: 本包所有封装方法均不接收 context 参数, 单次命令的上下文超时时间在 连接配置 Redis.ContextTimeout 中统一设定(未设置时默认 3s), 由封装内部为每次命令创建带超时的 context, 业务方无需在每次调用时传递超时参数。

app.Boot 场景经 Wire 一行接入(建连 + Ping 探活 + 关停释放):

app.MustRun(&app.Boot[Conf]{
	Wire: func(c *Conf) []app.Component {
		return []app.Component{cache.NewBoot(&c.Redis)}
	},
})

Redis 连接为全局单例: Connect 注入包级全局 Client(), Wire 中放置多个 cache.Boot 会互相覆盖。

独立使用:

r := &cache.Redis{
	Host:     "127.0.0.1",
	Port:     6379,
	Password: "123456",
	// 超时/连接池/锁配置可不设, 未设置(<=0)时自动使用默认值
}
if err := r.Connect(); err != nil { // 建连 + Ping 探活, 成功后注入全局
	panic(err)
}
defer cache.Close()

// 基础命令, 任意位置直接调用
_ = cache.Set("name", "note", time.Minute)
name, _ := cache.Get("name")

// 分布式锁(锁被占用时按配置自旋等待)
lock, err := cache.Lock("lock:order:1", time.Minute)
if err != nil {
	return // 获取失败
}
defer lock.Unlock()

// 延迟队列: sorted set 承载, 到期投递, 失败自动重试
q := cache.NewDelayQueue("orders:delay", func(payload string) error {
	return process(payload)
})
_ = q.Start()          // Init 钩子中启动消费协程
defer q.Stop()         // Close 钩子中停止并等待在途消息
_ = q.Push("order:1", 30*time.Second) // 30s 后可消费

本包未封装的高级命令(Scan/BLPop/Pipeline/订阅等)通过 Client() 获取原生客户端执行。

Index

Constants

This section is empty.

Variables

View Source
var (
	// ErrLockNotAcquired 未获取到锁: 锁被其他持有者占用, 或自旋等待超时
	ErrLockNotAcquired = errors.New("lock not acquired")
	// ErrLockNotHeld 释放/续期失败: 锁已过期或不再由当前持有者持有
	ErrLockNotHeld = errors.New("lock not held")
)

分布式锁相关错误

View Source
var Nil = redis.Nil

Nil key 不存在时命令返回的错误(同 redis.Nil), 调用方可用 errors.Is 判断

Functions

func Client

func Client() redis.UniversalClient

Client 获取全局 redis 客户端, 用于本包未封装的高级命令

func Close

func Close() error

Close 关闭 redis 连接并清空全局客户端, 可重复调用

func Decr

func Decr(key string) (int64, error)

Decr 将 key 中储存的数字值减一, 返回递减后的值

func DecrBy

func DecrBy(key string, decrement int64) (int64, error)

DecrBy 将 key 中储存的数字值减少指定减量

func Del

func Del(keys ...string) (int64, error)

Del 删除一个或多个 key, 返回实际删除的数量

func Exists

func Exists(keys ...string) (int64, error)

Exists 判断 key 是否存在, 返回存在的 key 数量

func Expire

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

Expire 设置 key 的过期时间, key 不存在时不生效并返回 false

func Get

func Get(key string) (string, error)

Get 获取 key 的值, key 不存在时返回 Nil 错误

func HDel

func HDel(key string, fields ...string) (int64, error)

HDel 删除哈希表 key 中的一个或多个字段, 返回实际删除的数量

func HGet

func HGet(key string, field string) (string, error)

HGet 获取哈希表 key 中字段 field 的值, field 不存在时返回 Nil 错误

func HGetAll

func HGetAll(key string) (map[string]string, error)

HGetAll 获取哈希表 key 中的所有字段与值

func HMSet

func HMSet(key string, m map[string]any) error

HMSet 批量设置哈希表 key 中的多个字段

func HSet

func HSet(key string, field string, value any) error

HSet 将哈希表 key 中的字段 field 的值设置为 value

func Incr

func Incr(key string) (int64, error)

Incr 将 key 中储存的数字值增一, 返回递增后的值

func IncrBy

func IncrBy(key string, increment int64) (int64, error)

IncrBy 将 key 中储存的数字值增加指定增量

func LLen

func LLen(key string) (int64, error)

LLen 获取列表 key 的长度

func LPop

func LPop(key string) (string, error)

LPop 移除并返回列表 key 的表头元素, 列表为空时返回 Nil 错误

func LPush

func LPush(key string, values ...any) (int64, error)

LPush 将一个或多个值插入列表 key 的表头, 返回列表长度

func LRange

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

LRange 获取列表 key 中指定区间内的元素(0 -1 表示全部)

func MGet

func MGet(keys ...string) ([]any, error)

MGet 批量获取多个 key 的值, 结果与 keys 一一对应, 不存在的 key 对应 nil

func MSet

func MSet(pairs ...any) error

MSet 批量设置多个 key-value, 按 "key1, value1, key2, value2" 传入

func Persist

func Persist(key string) (bool, error)

Persist 移除 key 的过期时间, 使其永久有效

func RPop

func RPop(key string) (string, error)

RPop 移除并返回列表 key 的表尾元素, 列表为空时返回 Nil 错误

func RPush

func RPush(key string, values ...any) (int64, error)

RPush 将一个或多个值插入列表 key 的表尾, 返回列表长度

func SAdd

func SAdd(key string, members ...any) (int64, error)

SAdd 向集合 key 添加一个或多个成员, 返回新增成员的数量

func SCard

func SCard(key string) (int64, error)

SCard 获取集合 key 的成员数量

func SIsMember

func SIsMember(key string, member any) (bool, error)

SIsMember 判断 member 是否是集合 key 的成员

func SMembers

func SMembers(key string) ([]string, error)

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

func SRem

func SRem(key string, members ...any) (int64, error)

SRem 移除集合 key 中的一个或多个成员, 返回实际移除的数量

func Set

func Set(key string, value any, expiration time.Duration) error

Set 设置 key 的值与过期时间(expiration<=0 时永不过期)

func SetClient

func SetClient(c redis.UniversalClient)

SetClient 设置全局 redis 客户端, 用于手动注入(如 cluster/sentinel 场景)

func SetNX

func SetNX(key string, value any, expiration time.Duration) (bool, error)

SetNX 仅当 key 不存在时设置值与过期时间, key 已存在时不做任何操作

func TTL

func TTL(key string) (time.Duration, error)

TTL 获取 key 的剩余过期时间, key 不存在或未设置过期时间时返回 -1/-2

func ZAdd

func ZAdd(key string, members ...ZMember) (int64, error)

ZAdd 向有序集合 key 添加一个或多个成员(已存在则更新分数), 返回新增成员的数量

func ZCard

func ZCard(key string) (int64, error)

ZCard 获取有序集合 key 的成员数量

func ZRange

func ZRange(key string, start, stop int64) ([]string, error)

ZRange 按分数升序获取有序集合 key 中指定区间内的成员(0 -1 表示全部)

func ZRem

func ZRem(key string, members ...any) (int64, error)

ZRem 移除有序集合 key 中的一个或多个成员, 返回实际移除的数量

func ZScore

func ZScore(key string, member any) (float64, error)

ZScore 获取有序集合 key 中成员 member 的分数, 成员不存在时返回 Nil 错误

Types

type Boot added in v1.0.4

type Boot struct {
	// Redis 连接配置
	Redis *Redis
}

Boot 组件适配器: 一行接入 app.Boot 的 Wire 装配钩子(结构化匹配 app.Component 约定, 无需 import app)。Redis 连接为全局单例: Connect 注入包级全局 Client(), Wire 中放置多个 cache.Boot 会互相覆盖。

func NewBoot added in v1.0.4

func NewBoot(r *Redis) *Boot

NewBoot 构建 Redis 组件适配器: Init 建立全局连接(含 Ping 探活), Close 释放连接。

cache.NewBoot(&c.Redis) // 连接 + 关停释放, 一行接入

func (*Boot) Close added in v1.0.4

func (b *Boot) Close()

Close 释放全局 Redis 连接(幂等, 未连接时为空操作)。

func (*Boot) Init added in v1.0.4

func (b *Boot) Init() error

Init 建立全局 Redis 连接。

func (*Boot) Name added in v1.0.4

func (b *Boot) Name() string

Name 组件名, 用于启动失败错误与关停日志标识。

type DelayQueue added in v1.0.4

type DelayQueue struct {
	// PollInterval 消费轮询间隔(<=0 时默认 1s), 决定投递精度下限
	PollInterval time.Duration
	// BatchSize 单轮最多取出的到期消息数(<=0 时默认 10)
	BatchSize int
	// MaxAttempts 最大尝试次数, 含首次消费(<=0 时默认 3)
	MaxAttempts int
	// RetryDelay 消费失败后的重试等待时长(<=0 时默认 1s)
	RetryDelay time.Duration
	// contains filtered or unexported fields
}

DelayQueue 基于 sorted set 的延迟队列: 以到期时间(毫秒时间戳)作 score, 消费协程轮询到期消息, 原子 ZREM 抢占成功后执行回调; 回调失败按 重试策略(Attempts/RetryDelay/MaxAttempts)重新入队, 超过最大尝试次数丢弃并记日志。

多实例部署时天然分摊消息(ZREM 原子抢占, 谁删到谁消费); 单队列为单协程顺序消费, 回调内不宜执行长阻塞任务。

func NewDelayQueue added in v1.0.4

func NewDelayQueue(key string, handler func(payload string) error) *DelayQueue

NewDelayQueue 创建延迟队列: key 为 redis 中的 sorted set 键名, handler 为消费回调(返回 nil 表示消费成功, 返回 error 触发重试)。 Start 之前可用字段调整轮询/重试策略。

func (*DelayQueue) Push added in v1.0.4

func (q *DelayQueue) Push(payload string, delay time.Duration) error

Push 投递一条消息: delay 之后可被消费(delay<=0 立即可消费)。 与队列是否已 Start 无关, 未连接 redis 时返回错误。

func (*DelayQueue) Start added in v1.0.4

func (q *DelayQueue) Start() error

Start 启动消费协程(非阻塞), 重复调用返回错误。 接入 app.Boot 时在 Init 钩子中调用。

func (*DelayQueue) Stop added in v1.0.4

func (q *DelayQueue) Stop()

Stop 停止消费并等待在途回调执行完成, 可重复调用。 接入 app.Boot 时在 Close 钩子中调用。

type DistributedLock

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

DistributedLock 分布式锁, 由 TryLock/Lock 获取成功后返回

func Lock

func Lock(key string, expiration time.Duration) (*DistributedLock, error)

Lock 获取分布式锁: 锁空闲时立即返回; 锁被占用时按配置的重试间隔 (Redis.LockRetryInterval, 默认 100ms)自旋重试, 超出配置的最大等待时间 (Redis.LockWaitTimeout, 默认 5s)仍未获取则返回 ErrLockNotAcquired; 未经 Connect 注入配置时(等待时间为 0)等价于 TryLock, 仅尝试一次

func TryLock

func TryLock(key string, expiration time.Duration) (*DistributedLock, error)

TryLock 尝试获取分布式锁, 仅尝试一次: 锁空闲时获取成功, 锁被占用时立即返回 ErrLockNotAcquired。 expiration 为锁的过期时间, 必须大于 0(防止持有者异常退出后锁永不释放)

func (*DistributedLock) Extend

func (l *DistributedLock) Extend(expiration time.Duration) (bool, error)

Extend 续期锁: 仅当锁仍由当前持有者持有时才将其过期时间重置为 expiration, 续期失败(锁已过期或被其他持有者持有)时返回 false

func (*DistributedLock) Unlock

func (l *DistributedLock) Unlock() error

Unlock 释放锁: 仅当锁仍由当前持有者持有时才删除; 锁已过期或被其他持有者持有时返回 ErrLockNotHeld

type Redis

type Redis struct {
	RedisPool // 连接池配置

	Host     string `yaml:"host" toml:"host" json:"host" mapstructure:"host"`                 // redis 主机
	Port     int    `yaml:"port" toml:"port" json:"port" mapstructure:"port"`                 // redis 端口
	Username string `yaml:"username" toml:"username" json:"username" mapstructure:"username"` // 用户名(redis 6.0+ acl)
	Password string `yaml:"password" toml:"password" json:"password" mapstructure:"password"` // 密码
	DB       int    `yaml:"db" toml:"db" json:"db" mapstructure:"db"`                         // 数据库编号

	// 超时配置, 封装内部创建命令 context 时使用
	DialTimeout    time.Duration `yaml:"dial_timeout" toml:"dial_timeout" json:"dial_timeout" mapstructure:"dial_timeout"`             // 建立连接的超时时间(<=0 时默认 5s)
	ReadTimeout    time.Duration `yaml:"read_timeout" toml:"read_timeout" json:"read_timeout" mapstructure:"read_timeout"`             // 读取(命令执行)的超时时间(<=0 时默认 3s)
	WriteTimeout   time.Duration `yaml:"write_timeout" toml:"write_timeout" json:"write_timeout" mapstructure:"write_timeout"`         // 写入的超时时间(<=0 时默认 3s)
	ContextTimeout time.Duration `yaml:"context_timeout" toml:"context_timeout" json:"context_timeout" mapstructure:"context_timeout"` // 单次命令的上下文超时时间(<=0 时默认 3s)

	// 分布式锁配置
	LockWaitTimeout   time.Duration `yaml:"lock_wait_timeout" toml:"lock_wait_timeout" json:"lock_wait_timeout" mapstructure:"lock_wait_timeout"`         // Lock 自旋获取锁的最大等待时间(<=0 时默认 5s, 仅尝试一次请使用 TryLock)
	LockRetryInterval time.Duration `yaml:"lock_retry_interval" toml:"lock_retry_interval" json:"lock_retry_interval" mapstructure:"lock_retry_interval"` // Lock 自旋获取锁的重试间隔(<=0 时默认 100ms)
}

Redis redis 连接配置

func (*Redis) Addr

func (r *Redis) Addr() string

Addr redis 连接地址

func (*Redis) Connect

func (r *Redis) Connect() error

Connect 连接 redis: 填充默认值 → 建连 → Ping 探活 → 注入全局

type RedisPool

type RedisPool struct {
	PoolSize        int           `yaml:"pool_size" toml:"pool_size" json:"pool_size" mapstructure:"pool_size"`                                     // 连接池最大连接数
	MaxIdleConns    int           `yaml:"max_idle_conns" toml:"max_idle_conns" json:"max_idle_conns" mapstructure:"max_idle_conns"`                 // 连接池最大空闲连接数
	MinIdleConns    int           `yaml:"min_idle_conns" toml:"min_idle_conns" json:"min_idle_conns" mapstructure:"min_idle_conns"`                 // 连接池最小空闲连接数(提前建立并保活)
	ConnMaxIdleTime time.Duration `yaml:"conn_max_idle_time" toml:"conn_max_idle_time" json:"conn_max_idle_time" mapstructure:"conn_max_idle_time"` // 连接最大空闲时间
	ConnMaxLifetime time.Duration `yaml:"conn_max_lifetime" toml:"conn_max_lifetime" json:"conn_max_lifetime" mapstructure:"conn_max_lifetime"`     // 连接最大生命周期
	MaxRetries      int           `yaml:"max_retries" toml:"max_retries" json:"max_retries" mapstructure:"max_retries"`                             // 命令执行失败的最大重试次数(-1 表示禁用重试)
}

RedisPool redis 连接池配置

type ZMember

type ZMember struct {
	Score  float64 // 分数
	Member any     // 成员
}

ZMember 有序集合成员

func ZRangeWithScores

func ZRangeWithScores(key string, start, stop int64) ([]ZMember, error)

ZRangeWithScores 按分数升序获取有序集合 key 中指定区间内的成员与分数

Jump to

Keyboard shortcuts

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