Pouvez-vous donner un exemple d'approche pour organiser la mise en cache des données dans un système?

En Go, pour organiser la mise en cache des données, on utilise souvent des structures de données intégrées, par exemple, map avec une logique supplémentaire pour gérer la durée de vie du cache (TTL). Une approche simple consiste à créer une structure qui stocke les données et leur heure de création, et lors de la requête, vérifier si les données sont périmées.

Exemple de cache simple avec TTL :

package main

import (
    "fmt"
    "sync"
    "time"
)

type cacheItem struct {
    value      interface{}
    expiration time.Time
}

type Cache struct {
    items map[string]cacheItem
    mu    sync.RWMutex
    ttl   time.Duration
}

func NewCache(ttl time.Duration) *Cache {
    return &Cache{
        items: make(map[string]cacheItem),
        ttl:   ttl,
    }
}

func (c *Cache) Set(key string, value interface{}) {
    c.mu.Lock()
    defer c.mu.Unlock()
    c.items[key] = cacheItem{
        value:      value,
        expiration: time.Now().Add(c.ttl),
    }
}

func (c *Cache) Get(key string) (interface{}, bool) {
    c.mu.RLock()
    defer c.mu.RUnlock()
    item, found := c.items[key]
    if !found || time.Now().After(item.expiration) {
        return nil, false
    }
    return item.value, true
}

func main() {
    cache := NewCache(5 * time.Minute)
    cache.Set("user_1", "John Doe")

    if val, ok := cache.Get("user_1"); ok {
        fmt.Println("Valeur en cache :", val)
    } else {
        fmt.Println("Valeur non trouvée ou expirée")
    }
}

Cette approche convient pour des cas simples. Pour des systèmes plus complexes, on utilise des bibliothèques spécialisées ou des caches externes (Redis, Memcached).