Go语言中实现带有过期时间的缓存管理

package main

import (
    "fmt"
    "time"

    "github.com/muesli/cache2go"
)

func main() {
    // 创建一个名为 "myCache" 的缓存实例
    cache := cache2go.Cache("myCache")

    // 定义一个要存储的结构体
    type MyData struct {
        Message string
    }
    val := MyData{"这是一个测试数据！"}

    // 将数据项 "valA" 添加到缓存中，并设置5秒后过期
    cache.Add("valA", 5*time.Second, &val)
    fmt.Println("数据 'valA' 已添加到缓存，5秒后过期。")

    // 尝试在过期前获取数据
    if item, err := cache.Value("valA"); err == nil {
        fmt.Printf("在过期前获取到数据: %v\n", item.Data().(*MyData).Message)
    } else {
        fmt.Printf("获取数据失败: %v\n", err)
    }

    // 等待6秒，确保数据过期
    time.Sleep(6 * time.Second)

    // 再次尝试获取数据，此时应已过期
    if _, err := cache.Value("valA"); err == nil {
        fmt.Printf("过期后仍然获取到数据，这不应该发生。\n")
    } else {
        fmt.Printf("过期后尝试获取数据，结果： %v\n", err)
    }
}

package main

import (
    "fmt"
    "time"

    "github.com/muesli/cache2go"
)

// 模拟从磁盘加载数据的函数
func loadFromDisk(key interface{}) interface{} {
    fmt.Printf("正在从磁盘为键 '%v' 加载数据...\n", key)
    // 模拟耗时操作
    time.Sleep(1 * time.Second)
    return fmt.Sprintf("从磁盘加载的数据 for %v", key)
}

func main() {
    cache := cache2go.Cache("diskCache")

    // 设置数据加载器
    cache.SetDataLoader(func(key interface{}) *cache2go.CacheItem {
        val := loadFromDisk(key) // 调用模拟的磁盘加载函数
        // 创建一个新的缓存项，0 表示使用缓存的默认过期时间，或可指定特定过期时间
        item := cache2go.CreateCacheItem(key, 5*time.Second, val)
        return &item
    })

    // 尝试获取一个不存在的键，此时会触发 DataLoader
    if item, err := cache.Value("diskKey1"); err == nil {
        fmt.Printf("通过 DataLoader 获取到数据: %v\n", item.Data())
    } else {
        fmt.Printf("获取数据失败: %v\n", err)
    }

    // 再次获取同一个键，这次将从缓存中直接获取，不会触发 DataLoader
    if item, err := cache.Value("diskKey1"); err == nil {
        fmt.Printf("再次从缓存获取到数据: %v\n", item.Data())
    }
}

package main

import (
    "fmt"
    "time"

    "github.com/patrickmn/go-cache"
)

func main() {
    // 创建一个缓存实例，默认过期时间为5分钟，每10分钟清理一次过期项
    // 这里我们使用 NoExpiration 表示默认不设置过期，但我们会在 Set 方法中指定
    c := cache.New(5*time.Minute, 10*time.Minute)

    // 添加一个键值对，设置10秒后过期
    c.Set("myKey", "我的缓存值", 10*time.Second)
    fmt.Println("数据 'myKey' 已添加到缓存，10秒后过期。")

    // 在过期前尝试获取数据
    if x, found := c.Get("myKey"); found {
        fmt.Printf("在过期前获取到数据: %s\n", x.(string))
    } else {
        fmt.Println("数据 'myKey' 未找到。")
    }

    // 等待11秒，确保数据过期
    time.Sleep(11 * time.Second)

    // 再次尝试获取数据，此时应已过期
    if _, found := c.Get("myKey"); !found {
        fmt.Println("过期后尝试获取数据，数据 'myKey' 未找到，符合预期。")
    } else {
        fmt.Println("过期后仍然获取到数据，这不应该发生。")
    }

    // 特殊过期时间：
    // cache.DefaultExpiration: 使用缓存实例的默认过期时间
    // cache.NoExpiration: 永不过期
    c.Set("neverExpire", "这个数据永不过期", cache.NoExpiration)
    fmt.Println("数据 'neverExpire' 已添加到缓存，永不过期。")
}

package main

import (
    "bytes"
    "fmt"
    "time"

    "github.com/patrickmn/go-cache"
)

func main() {
    // 创建第一个缓存实例
    c1 := cache.New(5*time.Minute, 10*time.Minute)
    c1.Set("item1", "这是第一个缓存实例的数据", cache.NoExpiration)
    c1.Set("item2", "这个数据会过期", 5*time.Second)

    fmt.Println("c1 初始数据:", c1.ItemCount())

    // 将 c1 的内容保存到一个字节缓冲区
    var buf bytes.Buffer
    if err := c1.Save(&buf); err != nil {
        fmt.Printf("保存缓存失败: %v\n", err)
        return
    }
    fmt.Println("c1 缓存已保存到缓冲区。")

    // 等待 item2 过期
    time.Sleep(6 * time.Second)
    fmt.Println("等待 item2 过期后 c1 数据:", c1.ItemCount()) // item2 此时应已过期

    // 创建第二个缓存实例
    c2 := cache.New(5*time.Minute, 10*time.Minute)
    fmt.Println("c2 初始数据:", c2.ItemCount())

    // 从缓冲区加载数据到 c2
    if err := c2.Load(&buf); err != nil {
        fmt.Printf("加载缓存失败: %v\n", err)
        return
    }
    fmt.Println("c2 缓存已从缓冲区加载。")
    fmt.Println("c2 加载后数据:", c2.ItemCount())

    // 检查 c2 中的数据
    if x, found := c2.Get("item1"); found {
        fmt.Printf("c2 中找到 item1: %s\n", x.(string))
    }
    if _, found := c2.Get("item2"); !found {
        fmt.Println("c2 中未找到 item2 (已过期，符合预期)。")
    }
}