Go: creare una cache in memory per le REST API

  • Go
  • Gabriele Romanato

Le cache in memory sono un componente cruciale per migliorare le prestazioni di una REST API. In Go, puoi facilmente implementare una cache in memoria per memorizzare temporaneamente i dati frequentemente richiesti dai client, riducendo così il carico sul tuo server e migliorando la velocità di risposta complessiva dell'API. In questo articolo, esploreremo come implementare una cache in memory per una REST API utilizzando il linguaggio di programmazione Go.

Per iniziare, importa le librerie Go necessarie per creare una cache in memoria. Il pacchetto sync ci aiuterà a gestire in modo sicuro l'accesso concorrente alla cache:


import (
    "sync"
)

Crea una struttura che rappresenti la cache in memoria. Questa struttura dovrebbe includere una mappa per archiviare i dati e un mutex per garantire l'accesso concorrente sicuro:


type MemoryCache struct {
    cache     map[string]interface{}
    mutex     sync.RWMutex
}

Nel tuo codice principale, inizializza una nuova istanza di MemoryCache:


func main() {
    cache := MemoryCache{
        cache: make(map[string]interface{}),
    }
    // ...
}

Quando ricevi una richiesta API, prima verifica se i dati richiesti sono già presenti nella cache. Se sì, restituiscili direttamente. In caso contrario, esegui il calcolo o il recupero dei dati e aggiungili alla cache per le future richieste:


func (c *MemoryCache) Get(key string) (interface{}, bool) {
    c.mutex.RLock()
    defer c.mutex.RUnlock()

    data, exists := c.cache[key]
    return data, exists
}

func (c *MemoryCache) Set(key string, data interface{}) {
    c.mutex.Lock()
    defer c.mutex.Unlock()

    c.cache[key] = data
}

Nelle tue route API, prima verifica se i dati richiesti sono presenti nella cache. Se lo sono, restituisci i dati dalla cache. Altrimenti, esegui la logica di gestione delle richieste come al solito e aggiungi i risultati alla cache per le future richieste:


func yourAPIRouteHandler(w http.ResponseWriter, r *http.Request) {
    key := r.URL.String()

    // Cerca nella cache
    if data, exists := cache.Get(key); exists {
        // Dati trovati nella cache, restituiscili
        respondWithJSON(w, http.StatusOK, data)
        return
    }

    // Dati non trovati nella cache, esegui la logica di gestione delle richieste
    result := fetchFromDatabaseOrComputeData()

    // Aggiungi i risultati alla cache per le future richieste
    cache.Set(key, result)

    respondWithJSON(w, http.StatusOK, result)
}

Conclusioni

Implementare una cache in memoria per una REST API in Go è un modo efficace per migliorare le prestazioni e ridurre il carico sul tuo server. Utilizzando la sincronizzazione con mutex, puoi garantire un accesso concorrente sicuro alla cache. Assicurati di gestire la logica di aggiunta e recupero dei dati dalla cache in modo appropriato nelle tue route API.

Torna su