Kannst du ein Beispiel für einen Ansatz zur Organisation des Cachings von Daten in einem System geben?

In Go werden häufig eingebaute Datenstrukturen wie map mit zusätzlicher Logik zur Verwaltung der Lebensdauer des Caches (TTL) verwendet. Ein einfacher Ansatz ist die Erstellung einer Struktur, die die Daten und ihre Erstellungszeit speichert, und bei der Abfrage zu prüfen, ob die Daten veraltet sind.

Beispiel für einen einfachen Cache mit 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("Cached value:", val)
    } else {
        fmt.Println("Value not found or expired")
    }
}

Dieser Ansatz eignet sich für einfache Anwendungsfälle. Für komplexere Systeme werden spezialisierte Bibliotheken oder externe Caches (Redis, Memcached) verwendet.