Go语言中实现带超时机制的数据存储与缓存策略

package main

import (
    "fmt"
    "time"

    "github.com/muesli/cache2go"
)

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

    // 定义一个要存储的结构体
    type MyData struct {
        ID   string
        Name string
    }
    val := MyData{ID: "123", Name: "Go Timeout Example"}

    // 添加一个键为 "dataA"，5秒后过期的数据
    // 第一个参数是键，第二个是过期时间，第三个是要存储的值
    cache.Add("dataA", 5*time.Second, &val)
    fmt.Println("Added 'dataA', will expire in 5 seconds.")

    // 尝试获取数据
    item, err := cache.Value("dataA")
    if err == nil {
        fmt.Printf("Retrieved 'dataA': %v\n", item.Data().(*MyData))
    } else {
        fmt.Printf("Error retrieving 'dataA': %v\n", err)
    }

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

    // 再次尝试获取数据，此时应该已经过期
    item, err = cache.Value("dataA")
    if err == nil {
        fmt.Printf("Retrieved 'dataA' after expiration: %v\n", item.Data().(*MyData))
    } else {
        fmt.Printf("Error retrieving 'dataA' after expiration: %v\n", err) // 预期会报错
    }

    // 停止缓存，释放资源
    cache.DeleteAll()
}

package main

import (
    "fmt"
    "time"

    "github.com/muesli/cache2go"
)

// 模拟从磁盘加载数据的函数
func loadFromDisk(key interface{}) interface{} {
    fmt.Printf("Loading data for key '%v' from disk...\n", key)
    // 实际应用中，这里会执行文件读取、数据库查询等操作
    time.Sleep(500 * time.Millisecond) // 模拟I/O延迟
    return fmt.Sprintf("Data from disk for key: %v", key)
}

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

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

    // 尝试获取一个不存在的键，此时会触发数据加载器
    item, err := cache.Value("diskKey1")
    if err == nil {
        fmt.Printf("Retrieved 'diskKey1': %v\n", item.Data())
    } else {
        fmt.Printf("Error retrieving 'diskKey1': %v\n", err)
    }

    // 再次获取同一个键，此时应该直接从缓存中获取，不再触发加载器
    item, err = cache.Value("diskKey1")
    if err == nil {
        fmt.Printf("Retrieved 'diskKey1' again: %v\n", item.Data())
    } else {
        fmt.Printf("Error retrieving 'diskKey1' again: %v\n", err)
    }

    cache.DeleteAll()
}

package main

import (
    "fmt"
    "time"

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

func main() {
    // 创建一个缓存实例，默认过期时间为5分钟，每10分钟清理一次过期项
    c := cache.New(5*time.Minute, 10*time.Minute)

    // 设置一个键为 "myKey"，10秒后过期的数据
    c.Set("myKey", "This is a go-cache value", 10*time.Second)
    fmt.Println("Added 'myKey', will expire in 10 seconds.")

    // 获取数据
    if x, found := c.Get("myKey"); found {
        fmt.Printf("Retrieved 'myKey': %s\n", x.(string))
    } else {
        fmt.Println("'myKey' not found.")
    }

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

    // 再次获取数据，此时应该已经过期
    if _, found := c.Get("myKey"); !found {
        fmt.Println("'myKey' not found after expiration (as expected).")
    } else {
        fmt.Println("'myKey' still found after expiration (unexpected).")
    }

    // 设置一个永不过期的项
    c.Set("neverExpire", "This item never expires", cache.NoExpiration)
    if x, found := c.Get("neverExpire"); found {
        fmt.Printf("Retrieved 'neverExpire': %s\n", x.(string))
    }
}

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", "Value1", cache.DefaultExpiration)
    c1.Set("item2", 123, 2*time.Second) // 短暂过期时间
    c1.Set("item3", []string{"a", "b"}, cache.NoExpiration)

    fmt.Println("Cache c1 before saving:")
    fmt.Printf("item1: %v, found: %t\n", c1.Get("item1"))
    fmt.Printf("item2: %v, found: %t\n", c1.Get("item2"))
    fmt.Printf("item3: %v, found: %t\n", c1.Get("item3"))

    // 将缓存保存到一个 bytes.Buffer 中（模拟文件）
    var b bytes.Buffer
    if err := c1.Save(&b); err != nil {
        fmt.Printf("Error saving cache: %v\n", err)
        return
    }
    fmt.Println("\nCache c1 saved to buffer.")

    // 等待 item2 过期
    time.Sleep(3 * time.Second)

    // 创建一个新的缓存实例
    c2 := cache.New(5*time.Minute, 10*time.Minute)

    // 从 buffer 加载缓存
    if err := c2.Load(&b); err != nil {
        fmt.Printf("Error loading cache: %v\n", err)
        return
    }
    fmt.Println("\nCache c2 loaded from buffer.")

    // 检查加载后的缓存内容
    fmt.Println("Cache c2 after loading:")
    // 注意：加载时，已过期的项不会被加载。
    // item2 在保存后等待了3秒，所以加载时应该已经过期，不会被包含。
    fmt.Printf("item1: %v, found: %t\n", c2.Get("item1")) // 应该找到
    fmt.Printf("item2: %v, found: %t\n", c2.Get("item2")) // 应该找不到 (已过期)
    fmt.Printf("item3: %v, found: %t\n", c2.Get("item3")) // 应该找到
}