Jak organizujesz pracę z zewnętrznym API w swoim…

Pracując z zewnętrznym API w projekcie Go, zazwyczaj organizuje się osobną warstwę lub pakiet odpowiedzialny za interakcję z tym API. Główne punkty:

Enkapsulacja logiki zapytań — tworzy się klienta z metodami dla każdego punktu końcowego API.
Obsługa błędów i limitów czasowych — użycie kontekstów (context.Context) do kontroli czasu wykonania.
Deserializacja i serializacja danych — praca z JSON lub innym formatem.
Ponowne próby i mechanizmy awaryjne — w razie potrzeby implementuje się retry i fallback.

Przykład prostego klienta dla zapytania GET:

package api

import (
    "context"
    "encoding/json"
    "net/http"
    "time"
)

type APIClient struct {
    baseURL    string
    httpClient *http.Client
}

func NewAPIClient(baseURL string) *APIClient {
    return &APIClient{
        baseURL: baseURL,
        httpClient: &http.Client{
            Timeout: 10 * time.Second,
        },
    }
}

type DataResponse struct {
    ID   int    `json:"id"`
    Name string `json:"name"`
}

func (c *APIClient) GetData(ctx context.Context, endpoint string) (*DataResponse, error) {
    req, err := http.NewRequestWithContext(ctx, "GET", c.baseURL+endpoint, nil)
    if err != nil {
        return nil, err
    }

    resp, err := c.httpClient.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()

    if resp.StatusCode != http.StatusOK {
        return nil, fmt.Errorf("nieoczekiwany status: %s", resp.Status)
    }

    var data DataResponse
    if err := json.NewDecoder(resp.Body).Decode(&data); err != nil {
        return nil, err
    }

    return &data, nil
}

W ten sposób w projekcie istnieje scentralizowany klient, który można używać w usługach lub obsługach, zapewniając czystą architekturę i łatwość testowania.

Jak organizujesz pracę z zewnętrznym API w swoim projekcie?