Meséljen egy olyan helyzetről, amikor sikerült növelnie egy REST API hatékonyságát.

Egy Go nyelvű projektben javítottam a REST API hatékonyságát azáltal, hogy optimalizáltam a kérésfeldolgozást és csökkentettem a válaszidőt.

Mit csináltam:

1. Gyorsítótárazás: gyakran kért adatok gyorsítótárazását végeztem in-memory cache segítségével (pl. Redis vagy beépített map mutex-szel), hogy csökkentsem az adatbázis terhelését.

2. Párhuzamos feldolgozás: goroutine-okat használtam az egymástól független műveletek párhuzamos végrehajtására a kérés feldolgozása során.

3. Adatbázis lekérdezések optimalizálása: átírtam az SQL lekérdezéseket, indexeket adtam hozzá, hogy csökkentsem a végrehajtási időt.

4. Context (context.Context) használata: a hosszú kérés időben történő megszakítására és az erőforrások felszabadítására.

Kód példa cache-eléssel és goroutine-kkal:

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()

    // Szimulált adatbázis kérés
    data := "adat az adatbázisból a " + 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")

    // Párhuzamos adatlekérés
    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, "Hiba", http.StatusInternalServerError)
        return
    }

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

Eredményként az API válaszideje csökkent, a terhelés az adatbázison pedig mérséklődött, ami javította a szolgáltatás általános teljesítményét.