Vertel over een situatie waarin je de efficiëntie van het werken met een REST API hebt kunnen verbeteren.

In een van mijn projecten in Go heb ik de efficiëntie van de REST API verbeterd door het verwerken van verzoeken te optimaliseren en de responstijd te verkorten.

Wat is gedaan:

1. Caching: ik heb caching toegevoegd voor vaak opgevraagde gegevens met behulp van een in-memory cache (bijvoorbeeld Redis of een ingebouwde map met mutex), om de belasting op de database te verminderen.

2. Parallel verwerking: ik heb goroutines gebruikt om onafhankelijke operaties parallel uit te voeren tijdens het verwerken van het verzoek.

3. Optimalisatie van databasequery's: ik heb SQL-query's herschreven, indexen toegevoegd om de uitvoeringstijd te verkorten.

4. Gebruik van context (context.Context): om lange verzoeken tijdig te onderbreken en bronnen vrij te maken.

Voorbeeld van code met caching en goroutines:

var cache = make(map[string]string)
var mu sync.RWMutex

func getData(key string) (string, error) {
    mu.RLock()
    if val, ok := cache[key]; ok {
        mu.RUnlock()
        return val, nil
    }
    mu.RUnlock()

    // Simulatie van een database aanvraag
    data := "gegevens uit DB voor " + key

    mu.Lock()
    cache[key] = data
    mu.Unlock()

    return data, nil
}

func handler(w http.ResponseWriter, r *http.Request) {
    key := r.URL.Query().Get("key")

    // Parallel gegevens ophalen
    var wg sync.WaitGroup
    var result string
    var err error

    wg.Add(1)
    go func() {
        defer wg.Done()
        result, err = getData(key)
    }()

    wg.Wait()

    if err != nil {
        http.Error(w, "Fout", http.StatusInternalServerError)
        return
    }

    w.Write([]byte(result))
}

Als resultaat is de API-responstijd verminderd en de belasting op de database afgenomen, wat de algehele prestaties van de service heeft verbeterd.