Go语言中实现带超时机制的数据存储：以缓存库为例

package main

import (
    "fmt"
    "time"

    "github.com/muesli/cache2go"
)

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

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

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

    // 尝试获取数据
    res, err := cache.Value("valA")
    if err == nil {
        fmt.Printf("获取到数据 'valA': %v\n", res.Data().(*MyData).X)
    } else {
        fmt.Printf("获取数据 'valA' 失败: %v\n", err)
    }

    // 等待6秒，观察数据是否过期
    time.Sleep(6 * time.Second)

    res, err = cache.Value("valA")
    if err == nil {
        fmt.Printf("过期后获取到数据 'valA': %v\n", res.Data().(*MyData).X)
    } else {
        fmt.Printf("过期后获取数据 'valA' 失败: %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("persistentCache")

    // 设置数据加载器
    cache.SetDataLoader(func(key interface{}) *cache2go.CacheItem {
        val := loadFromDisk(key) // 调用自定义的加载函数
        // 创建一个永不过期的缓存项，或设置一个默认过期时间
        item := cache2go.CreateCacheItem(key, 0, val) // 0 表示永不过期，或使用 cache.DefaultExpiration
        return &item
    })

    // 尝试获取一个不存在于缓存中的键，数据加载器将被触发
    res, err := cache.Value("keyFromDisk")
    if err == nil {
        fmt.Printf("通过数据加载器获取到数据: %v\n", res.Data())
    } else {
        fmt.Printf("获取数据失败: %v\n", err)
    }

    // 再次获取同一个键，这次将直接从缓存中返回
    res, err = cache.Value("keyFromDisk")
    if err == nil {
        fmt.Printf("再次获取到数据 (来自缓存): %v\n", res.Data())
    }
}

package main

import (
    "fmt"
    "time"

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

func main() {
    // 创建一个缓存实例，默认过期时间为5分钟，每30秒清理一次过期项
    // 或者使用 cache.NoExpiration 表示永不过期
    c := cache.New(5*time.Minute, 30*time.Second)

    // 添加一个数据项 "foo"，设置10秒后过期
    c.Set("foo", "bar", 10*time.Second)
    fmt.Println("数据 'foo' 已添加到缓存，10秒后过期。")

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

    // 等待11秒，观察数据是否过期
    time.Sleep(11 * time.Second)

    if x, found := c.Get("foo"); found {
        fmt.Printf("过期后获取到数据 'foo': %s\n", x.(string))
    } else {
        fmt.Println("过期后数据 'foo' 未找到。") // 此时应未找到
    }

    // 添加一个永不过期的数据项 (d = -1)
    c.Set("baz", 42, cache.NoExpiration)
    fmt.Println("数据 'baz' 已添加到缓存，永不过期。")
}

package main

import (
    "bytes"
    "fmt"
    "time"

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

func main() {
    c := cache.New(5*time.Minute, 30*time.Second)

    // 添加一些数据
    c.Set("item1", "value1", cache.DefaultExpiration)
    c.Set("item2", 123, 5*time.Second) // 5秒后过期
    c.Set("item3", []string{"a", "b"}, cache.NoExpiration)

    fmt.Println("原始缓存内容:")
    for k, v := range c.Items() {
        fmt.Printf("  %s: %v\n", k, v.Object)
    }

    // 将缓存保存到内存中的Buffer (模拟文件)
    var buf bytes.Buffer
    if err := c.Save(&buf); err != nil {
        fmt.Printf("保存缓存失败: %v\n", err)
        return
    }
    fmt.Println("\n缓存已保存。")

    // 模拟程序重启，创建一个新的缓存实例
    newCache := cache.New(5*time.Minute, 30*time.Second)

    // 从保存的数据中加载缓存
    if err := newCache.Load(&buf); err != nil {
        fmt.Printf("加载缓存失败: %v\n", err)
        return
    }
    fmt.Println("新缓存已从保存的数据中加载。")

    // 检查新缓存中的数据
    fmt.Println("加载后的新缓存内容:")
    for k, v := range newCache.Items() {
        fmt.Printf("  %s: %v\n", k, v.Object)
    }

    // 验证过期项是否正确处理
    time.Sleep(6 * time.Second) // 等待 item2 过期

    fmt.Println("\n等待 item2 过期后，再次检查新缓存内容:")
    if x, found := newCache.Get("item2"); found {
        fmt.Printf("  item2: %v (意外找到)\n", x)
    } else {
        fmt.Println("  item2: 未找到 (符合预期)")
    }
}