golang 开发 Redis与Memory统一接口方案

Cache Package

一个功能丰富、高性能的Go语言缓存库，支持内存缓存和Redis缓存，提供统一的接口和丰富的功能，适用于各种缓存场景。

功能特性

核心功能

• 统一接口：内存缓存和Redis缓存共享相同的接口
• 多种数据类型支持：通过Set/Get方法直接支持string、int、float、bool、struct等
• 结构体序列化：自动JSON序列化/反序列化结构体
• 过期时间管理：支持设置缓存过期时间
• 批量操作：高效的批量设置、获取和删除操作
• 缓存统计：完整的统计信息（命中率、操作次数等）

内存缓存特性

• 并发安全：使用读写锁确保线程安全
• 定时清理：5分钟自动清理过期缓存
• 实时过期检查：获取时检查过期状态

Redis缓存特性

• 类型转换：自动转换基本数据类型
• Pipeline支持：批量操作使用Pipeline提高效率
• 原生命令：使用Redis原生批量命令(MSET/MGET/DEL)

安装

go get -u github.com/liu-dc/cache

快速开始

内存缓存示例

import (
    "fmt"
    "time"
    "github.com/liu-dc/cache"
)

func main() {
    // 创建内存缓存实例
    memCache := cache.NewMemory()
    defer memCache.Uninstall()

    // 设置缓存
    memCache.Set("key", "value", 5*time.Minute)

    // 获取缓存
    if val, ok := memCache.GetString("key"); ok {
        fmt.Println("String value:", val)
    }

    // 结构体示例
    type User struct {
        ID   int    `json:"id"`
        Name string `json:"name"`
    }

    // 设置结构体
    user := User{ID: 1, Name: "John"}
    memCache.SetStruct("user:1", user, 5*time.Minute)

    // 获取结构体
    var retrievedUser User
    if memCache.GetStruct("user:1", &retrievedUser) {
        fmt.Printf("Retrieved user: %+v\n", retrievedUser)
    }

    // 批量操作
    values := map[string]interface{}{
        "key1": "value1",
        "key2": "value2",
    }
    memCache.SetMulti(values, 5*time.Minute)

    keys := []string{"key1", "key2"}
    results := memCache.GetMulti(keys)
    fmt.Println("Batch results:", results)

    // 统计信息
    stats := memCache.GetStats()
    fmt.Printf("Hit rate: %.2f%%\n", stats.HitRate*100)
}

Redis缓存示例

import (
    "fmt"
    "time"
    "github.com/liu-dc/cache"
)

func main() {
    // 创建Redis缓存实例
    redisCache := cache.NewRedis("localhost:6379", "", 0)
    defer redisCache.Uninstall()

    // 使用方法与内存缓存相同
    redisCache.Set("key", "value", 5*time.Minute)
    
    if val, ok := redisCache.GetString("key"); ok {
        fmt.Println("Redis value:", val)
    }

    // 结构体操作
    type Product struct {
        ID    int     `json:"id"`
        Name  string  `json:"name"`
        Price float64 `json:"price"`
    }

    product := Product{ID: 100, Name: "Product A", Price: 199.99}
    redisCache.SetStruct("product:100", product, 5*time.Minute)

    var retrievedProduct Product
    if redisCache.GetStruct("product:100", &retrievedProduct) {
        fmt.Printf("Retrieved product: %+v\n", retrievedProduct)
    }
}

API文档

ICache接口

基本操作

// 获取缓存值
Get(key string) (interface{}, bool)
// 获取字符串类型
GetString(key string) (string, bool)
// 获取整数类型
GetInt(key string) (int, bool)
// 获取浮点数类型
GetFloat(key string) (float64, bool)
// 获取布尔类型
GetBool(key string) (bool, bool)
// 获取结构体
GetStruct(key string, out interface{}) bool

// 设置缓存值（支持多种数据类型）
Set(key string, value interface{}, expiration time.Duration)
// 设置结构体
SetStruct(key string, value interface{}, expiration time.Duration) error

// 删除缓存
Del(key string)
// 检查缓存是否存在
Exists(key string) bool
// 获取匹配前缀的key
PrefixKey(key string) []string
// 设置过期时间
Expire(key string, expiration time.Duration)
// 卸载缓存（清理资源）
Uninstall()

批量操作

// 批量设置缓存
SetMulti(values map[string]interface{}, expiration time.Duration) error
// 批量获取缓存
GetMulti(keys []string) map[string]interface{}
// 批量删除缓存
DelMulti(keys []string)

统计功能

// 获取统计信息
GetStats() CacheStats
// 重置统计信息
ResetStats()

统计信息结构

type CacheStats struct {
    Hits            int64   // 缓存命中次数
    Misses          int64   // 缓存未命中次数
    SetCount        int64   // 设置缓存次数
    DelCount        int64   // 删除缓存次数
    TotalOperations int64   // 总操作次数
    ItemCount       int64   // 当前缓存项数量
    HitRate         float64 // 命中率
}

缓存统计

缓存库提供了完整的统计功能，可以监控缓存的使用情况：

// 获取统计信息
stats := memCache.GetStats()

// 输出统计信息
fmt.Printf("命中次数: %d\n", stats.Hits)
fmt.Printf("未命中次数: %d\n", stats.Misses)
fmt.Printf("设置缓存次数: %d\n", stats.SetCount)
fmt.Printf("删除缓存次数: %d\n", stats.DelCount)
fmt.Printf("总操作次数: %d\n", stats.TotalOperations)
fmt.Printf("命中率: %.2f%%\n", stats.HitRate*100)
fmt.Printf("当前缓存项: %d\n", stats.ItemCount)

// 重置统计信息
memCache.ResetStats()

性能优化

1. 内存缓存并发性能：

   • 使用读写锁(RWMutex)区分读操作和写操作
   • 读操作并发执行，写操作互斥

2. 过期清理优化：

   • 内存缓存每5分钟批量清理过期项
   • 获取时实时检查过期状态，避免返回过期数据

3. 批量操作效率：

   • 内存缓存批量操作只加一次锁
   • Redis缓存使用Pipeline和原生命令减少网络往返

4. 类型转换优化：

   • 直接操作基本数据类型，避免频繁转换
   • 结构体使用高效的JSON序列化

使用建议

1. 选择合适的缓存类型：

   • 本地数据使用内存缓存
   • 分布式环境使用Redis缓存

2. 设置合理的过期时间：

   • 根据数据更新频率设置过期时间
   • 重要数据可以使用较长过期时间或永不过期

3. 使用批量操作：

   • 频繁的缓存操作尽量使用批量API
   • 批量操作可以显著提高性能

4. 监控统计信息：

   • 定期检查缓存命中率
   • 根据统计信息调整缓存策略

测试

go test -v .