Kun je een voorbeeld geven van een aanpak voor het organiseren van gegevenscaching in een systeem?

In Go worden vaak ingebouwde datastructuren gebruikt, zoals map, met extra logica om de levensduur van de cache (TTL) te beheren. Een eenvoudige aanpak is het maken van een structuur die de gegevens en de aanmaakdatum opslaat, en bij het opvragen controleert of de gegevens niet verlopen zijn.

Voorbeeld van een eenvoudige cache met 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")
    }
}

Deze aanpak is geschikt voor eenvoudige gevallen. Voor complexere systemen worden gespecialiseerde bibliotheken of externe caches (Redis, Memcached) gebruikt.