杭州明婳科技
297 lines
8.0 KiB
Go
297 lines
8.0 KiB
Go
package cache
|
|
|
|
import (
|
|
"context"
|
|
"strings"
|
|
"sync"
|
|
"time"
|
|
|
|
"github.com/EthanCodeCraft/xlgo-core/config"
|
|
)
|
|
|
|
// KeyBuilder 缓存键名构建器（CK2 修复：mu 保护并发访问）。
|
|
// 使用场景: 多个小项目共用一台 Redis 服务器，每个项目设置不同前缀
|
|
type KeyBuilder struct {
|
|
mu sync.Mutex
|
|
prefix string // 项目/站点前缀，如 "site_a"
|
|
_separator string // 分隔符，默认 ":"
|
|
_cacheType string // 缓存类型标识，如 "cache"
|
|
}
|
|
|
|
// KeyBuilderOption 配置选项
|
|
type KeyBuilderOption func(*KeyBuilder)
|
|
|
|
// WithPrefix 设置前缀（项目/站点别名）
|
|
// 示例: WithPrefix("site_a") -> 所有 key 自动添加 "site_a" 前缀
|
|
func WithPrefix(prefix string) KeyBuilderOption {
|
|
return func(kb *KeyBuilder) {
|
|
if kb == nil {
|
|
return
|
|
}
|
|
kb.prefix = prefix
|
|
}
|
|
}
|
|
|
|
// WithSeparator 设置分隔符
|
|
// 示例: WithSeparator(":") -> "site_a:user:1"
|
|
func WithSeparator(separator string) KeyBuilderOption {
|
|
return func(kb *KeyBuilder) {
|
|
if kb == nil {
|
|
return
|
|
}
|
|
kb._separator = separator
|
|
}
|
|
}
|
|
|
|
// WithCacheType 设置缓存类型标识
|
|
// 示例: WithCacheType("session") -> "session_site_a_user:1"
|
|
func WithCacheType(cacheType string) KeyBuilderOption {
|
|
return func(kb *KeyBuilder) {
|
|
if kb == nil {
|
|
return
|
|
}
|
|
kb._cacheType = cacheType
|
|
}
|
|
}
|
|
|
|
// NewKeyBuilder 创建键名构建器
|
|
func NewKeyBuilder(opts ...KeyBuilderOption) *KeyBuilder {
|
|
kb := &KeyBuilder{
|
|
prefix: "",
|
|
_separator: ":",
|
|
_cacheType: "cache",
|
|
}
|
|
for _, opt := range opts {
|
|
if opt == nil {
|
|
continue
|
|
}
|
|
opt(kb)
|
|
}
|
|
return kb
|
|
}
|
|
|
|
// Build 构建完整键名（CK2 修复：mu 读保护）。
|
|
// 格式: {cacheType}{separator}{prefix}{separator}{key}
|
|
// 示例: kb.Build("user:1") -> "cache_site_a_user:1"
|
|
func (kb *KeyBuilder) Build(key string) string {
|
|
kb.mu.Lock()
|
|
defer kb.mu.Unlock()
|
|
parts := []string{}
|
|
if kb._cacheType != "" {
|
|
parts = append(parts, kb._cacheType)
|
|
}
|
|
if kb.prefix != "" {
|
|
parts = append(parts, kb.prefix)
|
|
}
|
|
parts = append(parts, key)
|
|
return strings.Join(parts, kb._separator)
|
|
}
|
|
|
|
// BuildTemp 构建临时缓存键名（CK2 修复：mu 读保护）。
|
|
// 格式: "temp{separator}{prefix}{separator}{key}"
|
|
func (kb *KeyBuilder) BuildTemp(key string) string {
|
|
kb.mu.Lock()
|
|
defer kb.mu.Unlock()
|
|
parts := []string{"temp"}
|
|
if kb.prefix != "" {
|
|
parts = append(parts, kb.prefix)
|
|
}
|
|
parts = append(parts, key)
|
|
return strings.Join(parts, kb._separator)
|
|
}
|
|
|
|
// BuildPerm 构建永久缓存键名（CK2 修复：mu 读保护）。
|
|
// 格式: "perm{separator}{prefix}{separator}{key}"
|
|
func (kb *KeyBuilder) BuildPerm(key string) string {
|
|
kb.mu.Lock()
|
|
defer kb.mu.Unlock()
|
|
parts := []string{"perm"}
|
|
if kb.prefix != "" {
|
|
parts = append(parts, kb.prefix)
|
|
}
|
|
parts = append(parts, key)
|
|
return strings.Join(parts, kb._separator)
|
|
}
|
|
|
|
// BuildLock 构建分布式锁键名（CK2 修复：mu 读保护）。
|
|
// 格式: "lock{separator}{prefix}{separator}{key}"
|
|
func (kb *KeyBuilder) BuildLock(key string) string {
|
|
kb.mu.Lock()
|
|
defer kb.mu.Unlock()
|
|
parts := []string{"lock"}
|
|
if kb.prefix != "" {
|
|
parts = append(parts, kb.prefix)
|
|
}
|
|
parts = append(parts, key)
|
|
return strings.Join(parts, kb._separator)
|
|
}
|
|
|
|
// BuildCounter 构建计数器键名（CK2 修复：mu 读保护）。
|
|
// 格式: "counter{separator}{prefix}{separator}{key}"
|
|
func (kb *KeyBuilder) BuildCounter(key string) string {
|
|
kb.mu.Lock()
|
|
defer kb.mu.Unlock()
|
|
parts := []string{"counter"}
|
|
if kb.prefix != "" {
|
|
parts = append(parts, kb.prefix)
|
|
}
|
|
parts = append(parts, key)
|
|
return strings.Join(parts, kb._separator)
|
|
}
|
|
|
|
// BuildSession 构建会话键名（CK2 修复：mu 读保护）。
|
|
// 格式: "session{separator}{prefix}{separator}{key}"
|
|
func (kb *KeyBuilder) BuildSession(key string) string {
|
|
kb.mu.Lock()
|
|
defer kb.mu.Unlock()
|
|
parts := []string{"session"}
|
|
if kb.prefix != "" {
|
|
parts = append(parts, kb.prefix)
|
|
}
|
|
parts = append(parts, key)
|
|
return strings.Join(parts, kb._separator)
|
|
}
|
|
|
|
// BuildPattern 构建匹配模式（用于 SCAN/Keys）（CK2 修复：mu 读保护）。
|
|
// 示例: kb.BuildPattern("user:*") -> "cache_site_a_user:*"
|
|
func (kb *KeyBuilder) BuildPattern(pattern string) string {
|
|
return kb.Build(pattern)
|
|
}
|
|
|
|
// GetPrefix 获取当前前缀（CK2 修复：mu 读保护）。
|
|
func (kb *KeyBuilder) GetPrefix() string {
|
|
kb.mu.Lock()
|
|
defer kb.mu.Unlock()
|
|
return kb.prefix
|
|
}
|
|
|
|
// SetPrefix 动态设置前缀（CK2 修复：mu 写保护，并发安全）。
|
|
func (kb *KeyBuilder) SetPrefix(prefix string) *KeyBuilder {
|
|
kb.mu.Lock()
|
|
defer kb.mu.Unlock()
|
|
kb.prefix = prefix
|
|
return kb
|
|
}
|
|
|
|
// ===== 全局键名构建器 =====
|
|
|
|
// globalKeyBuilder 全局构建器，受 globalKBMu 保护；globalKBOnce 保证自动初始化只执行一次（M13）。
|
|
var (
|
|
globalKeyBuilder *KeyBuilder
|
|
globalKBMu sync.RWMutex
|
|
globalKBOnce sync.Once
|
|
)
|
|
|
|
// InitKeyBuilder 初始化全局键名构建器
|
|
// 参数: prefix 站点别名，如果为空则自动从配置读取
|
|
// 示例:
|
|
//
|
|
// InitKeyBuilder("site_a") // 手动指定
|
|
// InitKeyBuilder("") // 自动从配置读取
|
|
// InitKeyBuilder("", WithSeparator(":")) // 自动读取 + 自定义分隔符
|
|
func InitKeyBuilder(prefix string, opts ...KeyBuilderOption) {
|
|
// 如果 prefix 为空，尝试从配置读取
|
|
if prefix == "" {
|
|
cfg := config.Get()
|
|
if cfg != nil {
|
|
prefix = cfg.GetSiteName()
|
|
}
|
|
}
|
|
|
|
opts = append([]KeyBuilderOption{WithPrefix(prefix)}, opts...)
|
|
kb := NewKeyBuilder(opts...)
|
|
globalKBMu.Lock()
|
|
globalKeyBuilder = kb
|
|
globalKBMu.Unlock()
|
|
}
|
|
|
|
// AutoInitKeyBuilder 自动从配置初始化键名构建器
|
|
// 配置示例:
|
|
//
|
|
// app:
|
|
// site_name: "site_a"
|
|
// env: "prod"
|
|
func AutoInitKeyBuilder(opts ...KeyBuilderOption) {
|
|
InitKeyBuilder("", opts...)
|
|
}
|
|
|
|
// GetKeyBuilder 获取全局键名构建器，未初始化时用 sync.Once 自动初始化一次（M13）。
|
|
func GetKeyBuilder() *KeyBuilder {
|
|
globalKBOnce.Do(func() {
|
|
// 仅在仍为 nil 时自动初始化（已由 InitKeyBuilder 设置则跳过）。
|
|
globalKBMu.RLock()
|
|
kb := globalKeyBuilder
|
|
globalKBMu.RUnlock()
|
|
if kb == nil {
|
|
AutoInitKeyBuilder()
|
|
}
|
|
})
|
|
globalKBMu.RLock()
|
|
defer globalKBMu.RUnlock()
|
|
return globalKeyBuilder
|
|
}
|
|
|
|
// K 快捷构建键名（使用全局构建器）
|
|
// 示例: cache.K("user:1") -> 自动添加前缀
|
|
func K(key string) string {
|
|
return GetKeyBuilder().Build(key)
|
|
}
|
|
|
|
// KTemp 快捷构建临时缓存键名
|
|
func KTemp(key string) string {
|
|
return GetKeyBuilder().BuildTemp(key)
|
|
}
|
|
|
|
// KPerm 快捷构建永久缓存键名
|
|
func KPerm(key string) string {
|
|
return GetKeyBuilder().BuildPerm(key)
|
|
}
|
|
|
|
// KLock 快捷构建锁键名
|
|
func KLock(key string) string {
|
|
return GetKeyBuilder().BuildLock(key)
|
|
}
|
|
|
|
// KCounter 快捷构建计数器键名
|
|
func KCounter(key string) string {
|
|
return GetKeyBuilder().BuildCounter(key)
|
|
}
|
|
|
|
// KSession 快捷构建会话键名
|
|
func KSession(key string) string {
|
|
return GetKeyBuilder().BuildSession(key)
|
|
}
|
|
|
|
// ===== 带键名构建器的缓存操作 =====
|
|
|
|
// SetWithPrefix 带前缀的缓存设置
|
|
func SetWithPrefix(ctx context.Context, key string, value any, ttl time.Duration, prefix string) error {
|
|
kb := NewKeyBuilder(WithPrefix(prefix))
|
|
return GetCache().Set(ctx, kb.Build(key), value, ttl)
|
|
}
|
|
|
|
// GetWithPrefix 带前缀的缓存获取
|
|
func GetWithPrefix(ctx context.Context, key string, dest any, prefix string) bool {
|
|
kb := NewKeyBuilder(WithPrefix(prefix))
|
|
return GetCache().Get(ctx, kb.Build(key), dest)
|
|
}
|
|
|
|
// DeleteWithPrefix 带前缀的缓存删除
|
|
func DeleteWithPrefix(ctx context.Context, key string, prefix string) error {
|
|
kb := NewKeyBuilder(WithPrefix(prefix))
|
|
return GetCache().Delete(ctx, kb.Build(key))
|
|
}
|
|
|
|
// LockWithPrefix 带前缀的分布式锁
|
|
func LockWithPrefix(ctx context.Context, key string, ttl time.Duration, prefix string) (bool, error) {
|
|
kb := NewKeyBuilder(WithPrefix(prefix))
|
|
return Lock(ctx, kb.BuildLock(key), ttl)
|
|
}
|
|
|
|
// UnlockWithPrefix 带前缀的锁释放
|
|
// 注意: 此函数不检查 Token，仅用于向后兼容，建议使用 NewLock/Unlock 组合
|
|
func UnlockWithPrefix(ctx context.Context, key string, prefix string) error {
|
|
kb := NewKeyBuilder(WithPrefix(prefix))
|
|
return UnlockByKey(ctx, kb.BuildLock(key))
|
|
}
|